home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / sbin / firehol < prev    next >
Text File  |  2005-10-18  |  174KB  |  6,413 lines
  1. #!/bin/bash
  2. #
  3. # Startup script to implement /etc/firehol/firehol.conf pre-defined rules.
  4. #
  5. # chkconfig: 2345 99 92
  6. #
  7. # description: creates stateful iptables packet filtering firewalls.
  8. #
  9. # by Costa Tsaousis <costa@tsaousis.gr>
  10. #
  11. # config: /etc/firehol/firehol.conf
  12. #
  13. # $Id: firehol.sh,v 1.226 2005/01/25 21:28:19 ktsaou Exp $
  14. #
  15.  
  16. # Make sure only root can run us.
  17. if [ ! "${UID}" = 0 ]
  18. then
  19.     echo >&2
  20.     echo >&2
  21.     echo >&2 "Only user root can run FireHOL."
  22.     echo >&2
  23. fi
  24.  
  25. # Remember who you are.
  26. FIREHOL_FILE="${0}"
  27. FIREHOL_DEFAULT_WORKING_DIRECTORY="${PWD}"
  28.  
  29. # ------------------------------------------------------------------------------
  30. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  31. # ------------------------------------------------------------------------------
  32. #
  33. # EXTERNAL/SYSTEM COMMANDS MANAGEMENT
  34. #
  35. # ------------------------------------------------------------------------------
  36. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  37. # ------------------------------------------------------------------------------
  38.  
  39. export PATH="${PATH}:/bin:/usr/bin:/sbin:/usr/sbin"
  40.  
  41. # External commands FireHOL will need.
  42. # If one of those is not found, FireHOL will refuse to run.
  43.  
  44. which_cmd() {
  45.     local block=1
  46.     if [ "a${1}" = "a-n" ]
  47.     then
  48.         local block=0
  49.         shift
  50.     fi
  51.     
  52.     unalias $2 >/dev/null 2>&1
  53.     local cmd=`which $2 2>/dev/null | head -n 1`
  54.     if [ $? -gt 0 -o ! -x "${cmd}" ]
  55.     then
  56.         if [ ${block} -eq 1 ]
  57.         then
  58.             echo >&2
  59.             echo >&2 "ERROR:    Command '$2' not found in the system path."
  60.             echo >&2 "    FireHOL requires this command for its operation."
  61.             echo >&2 "    Please install the required package and retry."
  62.             echo >&2
  63.             echo >&2 "    Note that you need an operational 'which' command"
  64.             echo >&2 "    for FireHOL to find all the external programs it"
  65.             echo >&2 "    needs. Check it yourself. Run:"
  66.             echo >&2
  67.             echo >&2 "    which $2"
  68.             exit 1
  69.         fi
  70.         return 1
  71.     fi
  72.     
  73.     eval $1=${cmd}
  74.     return 0
  75. }
  76.  
  77. # Check for a command during runtime.
  78. # Currently the following commands are required only when needed:
  79. #
  80. # wget or curl (either is fine)
  81. # gzcat
  82. #
  83. require_cmd() {
  84.     for x in $1
  85.     do
  86.         eval var=`echo ${x} | tr 'a-z' 'A-Z'`_CMD
  87.         eval val=\$\{${var}\}
  88.         if [ -z "${val}" ]
  89.         then
  90.             which_cmd -n "${var}" "${x}"
  91.             test $? -eq 0 && return 0
  92.         fi
  93.     done
  94.     
  95.     return 1
  96. }
  97.  
  98. which_cmd CAT_CMD cat
  99. which_cmd CUT_CMD cut
  100. which_cmd CHOWN_CMD chown
  101. which_cmd CHMOD_CMD chmod
  102. which_cmd DATE_CMD date
  103. which_cmd EGREP_CMD egrep
  104. which_cmd EXPR_CMD expr
  105. which_cmd GAWK_CMD gawk
  106. which_cmd GREP_CMD grep
  107. which_cmd HEAD_CMD head
  108. which_cmd HOSTNAME_CMD hostname
  109. which_cmd IP_CMD ip
  110. which_cmd IPTABLES_CMD iptables
  111. which_cmd IPTABLES_SAVE_CMD iptables-save
  112. which_cmd LESS_CMD less
  113. which_cmd LSMOD_CMD lsmod
  114. which_cmd MKDIR_CMD mkdir
  115. which_cmd MV_CMD mv
  116. which_cmd MODPROBE_CMD modprobe
  117. which_cmd NETSTAT_CMD netstat
  118. which_cmd RENICE_CMD renice
  119. which_cmd RM_CMD rm
  120. which_cmd SED_CMD sed
  121. which_cmd SORT_CMD sort
  122. which_cmd SYSCTL_CMD sysctl
  123. which_cmd TOUCH_CMD touch
  124. which_cmd TR_CMD tr
  125. which_cmd UNAME_CMD uname
  126. which_cmd UNIQ_CMD uniq
  127.  
  128. # Make sure our generated files cannot be accessed by anyone else.
  129. umask 077
  130.  
  131. # Be nice on production environments
  132. ${RENICE_CMD} 10 $$ >/dev/null 2>/dev/null
  133.  
  134. # Find our minor version
  135. firehol_minor_version() {
  136. ${CAT_CMD} <<"EOF" | ${CUT_CMD} -d ' ' -f 3 | ${CUT_CMD} -d '.' -f 2
  137. $Id: firehol.sh,v 1.226 2005/01/25 21:28:19 ktsaou Exp $
  138. EOF
  139. }
  140.  
  141. FIREHOL_MINOR_VERSION=`firehol_minor_version`
  142. ${EXPR_CMD} ${FIREHOL_MINOR_VERSION} + 0 >/dev/null 2>&1
  143. if [ $? -ne 0 ]
  144. then
  145.     FIREHOL_MINOR_VERSION=220
  146. fi
  147.  
  148.  
  149. # Initialize iptables
  150. ${IPTABLES_CMD} -nxvL >/dev/null 2>&1
  151.  
  152.  
  153. # ------------------------------------------------------------------------------
  154. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  155. # ------------------------------------------------------------------------------
  156. #
  157. # GLOBAL DEFAULTS
  158. #
  159. # ------------------------------------------------------------------------------
  160. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  161. # ------------------------------------------------------------------------------
  162.  
  163. # ----------------------------------------------------------------------
  164. # Directories and files
  165.  
  166. # These files will be created and deleted during our run.
  167. FIREHOL_DIR="/tmp/.firehol-tmp-$$-${RANDOM}-${RANDOM}"
  168. FIREHOL_CHAINS_DIR="${FIREHOL_DIR}/chains"
  169. FIREHOL_OUTPUT="${FIREHOL_DIR}/firehol-out.sh"
  170. FIREHOL_SAVED="${FIREHOL_DIR}/firehol-save.sh"
  171. FIREHOL_TMP="${FIREHOL_DIR}/firehol-tmp.sh"
  172.  
  173. FIREHOL_SPOOL_DIR="/var/spool/firehol"
  174.  
  175. # The default configuration file
  176. # It can be changed on the command line
  177. FIREHOL_CONFIG_DIR="/etc/firehol"
  178. FIREHOL_CONFIG="${FIREHOL_CONFIG_DIR}/firehol.conf"
  179.  
  180. # Where /etc/init.d/iptables expects its configuration?
  181. # Leave it empty for automatic detection
  182. FIREHOL_AUTOSAVE=
  183.  
  184.  
  185. # ------------------------------------------------------------------------------
  186. # Make sure we automatically cleanup when we exit.
  187. # WHY:
  188. # Even a CTRL-C will call this and we will not leave temp files.
  189. # Also, if a configuration file breaks, we will detect this too.
  190.  
  191. firehol_exit() {
  192.     if [ -f "${FIREHOL_SAVED}" ]
  193.     then
  194.         echo
  195.         echo -n $"FireHOL: Restoring old firewall:"
  196.         iptables-restore <"${FIREHOL_SAVED}"
  197.         if [ $? -eq 0 ]
  198.         then
  199.             success $"FireHOL: Restoring old firewall:"
  200.         else
  201.             failure $"FireHOL: Restoring old firewall:"
  202.         fi
  203.         echo
  204.     fi
  205.     
  206.     test -d "${FIREHOL_DIR}" && ${RM_CMD} -rf "${FIREHOL_DIR}"
  207.     return 0
  208. }
  209.  
  210. # Run our exit even if we don't call exit.
  211. trap firehol_exit EXIT
  212.  
  213.  
  214. # ------------------------------------------------------------------------------
  215. # Create the directories we need.
  216.  
  217. if [ ! -d "${FIREHOL_CONFIG_DIR}" -a -f /etc/firehol.conf ]
  218. then
  219.     "${MKDIR_CMD}" "${FIREHOL_CONFIG_DIR}"            || exit 1
  220.     "${CHOWN_CMD}" root:root "${FIREHOL_CONFIG_DIR}"    || exit 1
  221.     "${CHMOD_CMD}" 700 "${FIREHOL_CONFIG_DIR}"        || exit 1
  222.     "${MV_CMD}" /etc/firehol.conf "${FIREHOL_CONFIG}"    || exit 1
  223.     
  224.     echo >&2
  225.     echo >&2
  226.     echo >&2 "NOTICE: Your config file /etc/firehol.conf has been moved to ${FIREHOL_CONFIG}"
  227.     echo >&2
  228.     sleep 5
  229. fi
  230.  
  231. # Externally defined services can be placed in "${FIREHOL_CONFIG_DIR}/services/"
  232. if [ ! -d "${FIREHOL_CONFIG_DIR}/services" ]
  233. then
  234.     "${MKDIR_CMD}" "${FIREHOL_CONFIG_DIR}/services"
  235.     if [ $? -ne 0 ]
  236.     then
  237.         echo >&2
  238.         echo >&2
  239.         echo >&2 "FireHOL needs to create the directory '${FIREHOL_CONFIG_DIR}/services', but it cannot."
  240.         echo >&2 "Possibly you have a file with this name, or something else is happening."
  241.         echo >&2 "Please solve this issue and retry".
  242.         echo >&2
  243.         exit 1
  244.     fi
  245.     "${CHOWN_CMD}" root:root "${FIREHOL_CONFIG_DIR}/services"
  246.     "${CHMOD_CMD}" 700 "${FIREHOL_CONFIG_DIR}/services"
  247. fi
  248.  
  249. # Remove any old directories that might be there.
  250. if [ -d "${FIREHOL_DIR}" ]
  251. then
  252.     "${RM_CMD}" -rf "${FIREHOL_DIR}"
  253.     if [ $? -ne 0 -o -e "${FIREHOL_DIR}" ]
  254.     then
  255.         echo >&2
  256.         echo >&2
  257.         echo >&2 "Cannot clean temporary directory '${FIREHOL_DIR}'."
  258.         echo >&2
  259.         exit 1
  260.     fi
  261. fi
  262. "${MKDIR_CMD}" "${FIREHOL_DIR}"                || exit 1
  263. "${MKDIR_CMD}" "${FIREHOL_CHAINS_DIR}"            || exit 1
  264.  
  265.  
  266. # Make sure we have a directory for our data.
  267. if [ ! -d "${FIREHOL_SPOOL_DIR}" ]
  268. then
  269.     "${MKDIR_CMD}" "${FIREHOL_SPOOL_DIR}"            || exit 1
  270.     "${CHOWN_CMD}" root:root "${FIREHOL_CONFIG_DIR}"    || exit 1
  271.     "${CHMOD_CMD}" 700 "${FIREHOL_CONFIG_DIR}"        || exit 1
  272. fi
  273.  
  274.  
  275. # ------------------------------------------------------------------------------
  276. # IP definitions
  277.  
  278. # IANA Reserved IPv4 address space
  279. # Suggested by Fco.Felix Belmonte <ffelix@gescosoft.com>
  280. # Optimized (CIDR) by Marc 'HE' Brockschmidt <marc@marcbrockschmidt.de>
  281. # Further optimized and reduced by http://www.vergenet.net/linux/aggregate/
  282. # The supplied get-iana.sh uses 'aggregate-flim' if it finds it in the path.
  283. RESERVED_IPS="0.0.0.0/7 2.0.0.0/8 5.0.0.0/8 7.0.0.0/8 23.0.0.0/8 27.0.0.0/8 31.0.0.0/8 36.0.0.0/7 39.0.0.0/8 41.0.0.0/8 42.0.0.0/8 73.0.0.0/8 74.0.0.0/7 76.0.0.0/6 89.0.0.0/8 90.0.0.0/7 92.0.0.0/6 96.0.0.0/3 173.0.0.0/8 174.0.0.0/7 176.0.0.0/5 184.0.0.0/6 189.0.0.0/8 190.0.0.0/8 197.0.0.0/8 223.0.0.0/8 240.0.0.0/4"
  284.  
  285. # Private IPv4 address space
  286. # Suggested by Fco.Felix Belmonte <ffelix@gescosoft.com>
  287. # Revised by me according to RFC 3330. Explanation:
  288. # 10.0.0.0/8       => RFC 1918: IANA Private Use
  289. # 169.254.0.0/16   => Link Local
  290. # 192.0.2.0/24     => Test Net
  291. # 192.88.99.0/24   => RFC 3068: 6to4 anycast & RFC 2544: Benchmarking addresses
  292. # 192.168.0.0/16   => RFC 1918: Private use
  293. PRIVATE_IPS="10.0.0.0/8 169.254.0.0/16 172.16.0.0/12 192.0.2.0/24 192.88.99.0/24 192.168.0.0/16"
  294.  
  295. # The multicast address space
  296. MULTICAST_IPS="224.0.0.0/4"
  297.  
  298. # A shortcut to have all the Internet unroutable addresses in one
  299. # variable
  300. UNROUTABLE_IPS="${RESERVED_IPS} ${PRIVATE_IPS}"
  301.  
  302. # ----------------------------------------------------------------------
  303.  
  304. # The default policy for the interface commands of the firewall.
  305. # This can be controlled on a per interface basis using the
  306. # policy interface subscommand. 
  307. DEFAULT_INTERFACE_POLICY="DROP"
  308.  
  309. # Which is the filter table chains policy during firewall activation?
  310. FIREHOL_INPUT_ACTIVATION_POLICY="ACCEPT"
  311. FIREHOL_OUTPUT_ACTIVATION_POLICY="ACCEPT"
  312. FIREHOL_FORWARD_ACTIVATION_POLICY="ACCEPT"
  313.  
  314. # Should we drop all INVALID packets always?
  315. FIREHOL_DROP_INVALID=0
  316.  
  317. # What to do with unmatched packets?
  318. # To change these, simply define them the configuration file.
  319. UNMATCHED_INPUT_POLICY="DROP"
  320. UNMATCHED_OUTPUT_POLICY="DROP"
  321. UNMATCHED_ROUTER_POLICY="DROP"
  322.  
  323. # Options for iptables LOG action.
  324. # These options will be added to all LOG actions FireHOL will generate.
  325. # To change them, type such a line in the configuration file.
  326. # FIREHOL_LOG_OPTIONS="--log-tcp-sequence --log-tcp-options --log-ip-options"
  327. FIREHOL_LOG_OPTIONS=""
  328. FIREHOL_LOG_LEVEL="warning"
  329. FIREHOL_LOG_MODE="LOG"
  330. FIREHOL_LOG_FREQUENCY="1/second"
  331. FIREHOL_LOG_BURST="5"
  332.  
  333. # The client ports to be used for "default" client ports when the
  334. # client specified is a foreign host.
  335. # We give all ports above 1000 because a few systems (like Solaris)
  336. # use this range.
  337. # Note that FireHOL will ask the kernel for default client ports of
  338. # the local host. This only applies to client ports of remote hosts.
  339. DEFAULT_CLIENT_PORTS="1024:65535"
  340.  
  341. # Get the default client ports from the kernel configuration.
  342. # This is formed to a range of ports to be used for all "default"
  343. # client ports when the client specified is the localhost.
  344. LOCAL_CLIENT_PORTS_LOW=`${SYSCTL_CMD} net.ipv4.ip_local_port_range | ${CUT_CMD} -d '=' -f 2 | ${CUT_CMD} -f 1`
  345. LOCAL_CLIENT_PORTS_HIGH=`${SYSCTL_CMD} net.ipv4.ip_local_port_range | ${CUT_CMD} -d '=' -f 2 | ${CUT_CMD} -f 2`
  346. LOCAL_CLIENT_PORTS="${LOCAL_CLIENT_PORTS_LOW}:${LOCAL_CLIENT_PORTS_HIGH}"
  347.  
  348.  
  349. # ----------------------------------------------------------------------
  350. # This is our version number. It is increased when the configuration
  351. # file commands and arguments change their meaning and usage, so that
  352. # the user will have to review it more precisely.
  353. FIREHOL_VERSION=5
  354.  
  355.  
  356. # ----------------------------------------------------------------------
  357. # The initial line number of the configuration file.
  358. FIREHOL_LINEID="INIT"
  359.  
  360. # Variable kernel module requirements.
  361. # Suggested by Fco.Felix Belmonte <ffelix@gescosoft.com>
  362. # Note that each of the complex services
  363. # may add to this variable the kernel modules it requires.
  364. # See rules_ftp() bellow for an example.
  365. FIREHOL_KERNEL_MODULES=""
  366. #
  367. # In the configuration file you can write:
  368. #
  369. #                     require_kernel_module <module_name>
  370. # 
  371. # to have FireHOL require a specific module for the configurarion.
  372.  
  373. # Set this to 1 in the configuration file to have FireHOL complex
  374. # services' rules load NAT kernel modules too.
  375. FIREHOL_NAT=0
  376.  
  377. # Set this to 1 in the configuration file if routing should be enabled
  378. # in the kernel.
  379. FIREHOL_ROUTING=0
  380.  
  381. # Services may add themeselves to this variable so that the service "all" will
  382. # also call them.
  383. # By default it is empty - only rules programmers should change this.
  384. ALL_SHOULD_ALSO_RUN=
  385.  
  386.  
  387. # ------------------------------------------------------------------------------
  388. # Various Defaults
  389.  
  390. # If set to 1, we are just going to present the resulting firewall instead of
  391. # installing it.
  392. # It can be changed on the command line
  393. FIREHOL_DEBUG=0
  394.  
  395. # If set to 1, the firewall will be saved for normal iptables processing.
  396. # It can be changed on the command line
  397. FIREHOL_SAVE=0
  398.  
  399. # If set to 1, the firewall will be restored if you don't commit it.
  400. # It can be changed on the command line
  401. FIREHOL_TRY=1
  402.  
  403. # If set to 1, FireHOL enters interactive mode to answer questions.
  404. # It can be changed on the command line
  405. FIREHOL_EXPLAIN=0
  406.  
  407. # If set to 1, FireHOL enters a wizard mode to help the user build a firewall.
  408. # It can be changed on the command line
  409. FIREHOL_WIZARD=0
  410.  
  411. # If set to 0, FireHOL will not try to load the required kernel modules.
  412. # It can be set in the configuration file.
  413. FIREHOL_LOAD_KERNEL_MODULES=1
  414.  
  415. # If set to 1, FireHOL will output the commands of the configuration file
  416. # with variables expanded.
  417. FIREHOL_CONF_SHOW=1
  418.  
  419.  
  420. # ------------------------------------------------------------------------------
  421. # Keep information about the current primary command
  422. # Primary commands are: interface, router
  423.  
  424. work_counter=0
  425. work_cmd=
  426. work_realcmd=("(unset)")
  427. work_name=
  428. work_inface=
  429. work_outface=
  430. work_policy="${DEFAULT_INTERFACE_POLICY}"
  431. work_error=0
  432. work_function="Initializing"
  433.  
  434.  
  435. # ------------------------------------------------------------------------------
  436. # Keep status information
  437.  
  438. # 0 = no errors, 1 = there were errors in the script
  439. work_final_status=0
  440.  
  441. # This variable is used for generating dynamic chains when needed for
  442. # combined negative statements (AND) implied by the "not" parameter
  443. # to many FireHOL directives.
  444. # What FireHOL is doing to accomplish this, is to produce dynamically
  445. # a linked list of iptables chains with just one condition each, making
  446. # the packets to traverse from chain to chain when matched, to reach
  447. # their final destination.
  448. FIREHOL_DYNAMIC_CHAIN_COUNTER=1
  449.  
  450. # If set to 0, FireHOL will not trust interface lo for all traffic.
  451. # This means the admin could setup a firewall on lo.
  452. FIREHOL_TRUST_LOOPBACK=1
  453.  
  454. # Services API version
  455. FIREHOL_SERVICES_API="1"
  456.  
  457.  
  458. # ------------------------------------------------------------------------------
  459. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  460. # ------------------------------------------------------------------------------
  461. #
  462. # SIMPLE SERVICES DEFINITIONS
  463. #
  464. # ------------------------------------------------------------------------------
  465. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  466. # ------------------------------------------------------------------------------
  467. # The following are definitions for simple services.
  468. # We define as "simple" the services that are implemented using a single socket,
  469. # initiated by the client and used by the server.
  470. #
  471. # The following list is sorted by service name.
  472.  
  473. server_AH_ports="51/any"
  474. client_AH_ports="any"
  475.  
  476. # Debian package proxy
  477. server_aptproxy_ports="tcp/9999"
  478. client_aptproxy_ports="default"
  479.  
  480. # APC UPS Server (these ports have to be accessible on all machines NOT
  481. # directly connected to the UPS (e.g. the slaves)
  482. server_apcupsd_ports="tcp/6544"
  483. client_apcupsd_ports="default"
  484.  
  485. server_apcupsdnis_ports="tcp/3551"
  486. client_apcupsdnis_ports="default"
  487.  
  488. server_asterisk_ports="tcp/5038"
  489. client_asterisk_ports="default"
  490.  
  491. server_cups_ports="tcp/631 udp/631"
  492. client_cups_ports="default 631"
  493.  
  494. server_cvspserver_ports="tcp/2401"
  495. client_cvspserver_ports="default"
  496.  
  497. server_darkstat_ports="tcp/666"
  498. client_darkstat_ports="default"
  499.  
  500. server_daytime_ports="tcp/13"
  501. client_daytime_ports="default"
  502.  
  503. server_dcc_ports="udp/6277"
  504. client_dcc_ports="default"
  505.  
  506. server_dcpp_ports="tcp/1412 udp/1412"
  507. client_dcpp_ports="default"
  508.  
  509. server_dns_ports="udp/53 tcp/53"
  510. client_dns_ports="any"
  511.  
  512. # DHCP Relaying (server is the relay server which behaves like a client
  513. # towards the real DHCP Server); I'm not sure about this one...
  514. server_dhcprelay_ports="udp/67"
  515. client_dhcprelay_ports="67"
  516.  
  517. server_dict_ports="tcp/2628"
  518. client_dict_ports="default"
  519.  
  520. # DISTCC is the distributed gcc for Gentoo
  521. server_distcc_ports="tcp/3632"
  522. client_distcc_ports="default"
  523.  
  524. server_eserver_ports="tcp/4661 udp/4661 udp/4665"
  525. client_eserver_ports="any"
  526.  
  527. server_ESP_ports="50/any"
  528. client_ESP_ports="any"
  529.  
  530. server_echo_ports="tcp/7"
  531. client_echo_ports="default"
  532.  
  533. server_finger_ports="tcp/79"
  534. client_finger_ports="default"
  535.  
  536. # giFT modules' ports
  537. # Gnutella  = tcp/4302
  538. # FastTrack = tcp/1214
  539. # OpenFT    = tcp/2182 tcp/2472
  540. server_gift_ports="tcp/4302 tcp/1214 tcp/2182 tcp/2472"
  541. client_gift_ports="any"
  542.  
  543. # giFT User Interface connections
  544. server_giftui_ports="tcp/1213"
  545. client_giftui_ports="default"
  546.  
  547. # gkrellmd (from gkrellm.net)
  548. server_gkrellmd_ports="tcp/19150"
  549. client_gkrellmd_ports="default"
  550.  
  551. server_GRE_ports="47/any"
  552. client_GRE_ports="any"
  553.  
  554. server_h323_ports="tcp/1720 tcp/1731"
  555. client_h323_ports="default"
  556.  
  557. # We assume heartbeat uses ports in the range 690 to 699
  558. server_heartbeat_ports="udp/690:699"
  559. client_heartbeat_ports="default"
  560.  
  561. server_http_ports="tcp/80"
  562. client_http_ports="default"
  563.  
  564. server_https_ports="tcp/443"
  565. client_https_ports="default"
  566.  
  567. server_iax_ports="udp/5036"
  568. client_iax_ports="default"
  569.  
  570. server_iax2_ports="udp/5469 udp/4569"
  571. client_iax2_ports="default"
  572.  
  573. server_ICMP_ports="icmp/any"
  574. client_ICMP_ports="any"
  575.  
  576. server_icmp_ports="icmp/any"
  577. client_icmp_ports="any"
  578. # ALL_SHOULD_ALSO_RUN="${ALL_SHOULD_ALSO_RUN} icmp"
  579.  
  580. # Squid' ICP port
  581. server_icp_ports="udp/3130"
  582. client_icp_ports="3130"
  583.  
  584. server_ident_ports="tcp/113"
  585. client_ident_ports="default"
  586.  
  587. server_imap_ports="tcp/143"
  588. client_imap_ports="default"
  589.  
  590. server_imaps_ports="tcp/993"
  591. client_imaps_ports="default"
  592.  
  593. server_irc_ports="tcp/6667"
  594. client_irc_ports="default"
  595. require_irc_modules="ip_conntrack_irc"
  596. require_irc_nat_modules="ip_nat_irc"
  597. ALL_SHOULD_ALSO_RUN="${ALL_SHOULD_ALSO_RUN} irc"
  598.  
  599. # for IPSec Key negotiation
  600. server_isakmp_ports="udp/500"
  601. client_isakmp_ports="500"
  602.  
  603. server_jabber_ports="tcp/5222 tcp/5223"
  604. client_jabber_ports="default"
  605.  
  606. server_jabberd_ports="tcp/5222 tcp/5223 tcp/5269"
  607. client_jabberd_ports="default"
  608.  
  609. server_ldap_ports="tcp/389"
  610. client_ldap_ports="default"
  611.  
  612. server_ldaps_ports="tcp/636"
  613. client_ldaps_ports="default"
  614.  
  615. server_lpd_ports="tcp/515"
  616. client_lpd_ports="721:731 default"
  617.  
  618. server_microsoft_ds_ports="tcp/445"
  619. client_microsoft_ds_ports="default"
  620.  
  621. server_mms_ports="tcp/1755 udp/1755"
  622. client_mms_ports="default"
  623. require_mms_modules="ip_conntrack_mms"
  624. require_mms_nat_modules="ip_nat_mms"
  625. # this will produce warnings on most distribution
  626. # because the mms module is not there:
  627. # ALL_SHOULD_ALSO_RUN="${ALL_SHOULD_ALSO_RUN} mms"
  628.  
  629. server_msn_ports="tcp/6891"
  630. client_msn_ports="default"
  631.  
  632. server_mysql_ports="tcp/3306"
  633. client_mysql_ports="default"
  634.  
  635. # Veritas NetBackup
  636. server_netbackup_ports="tcp/13701 tcp/13711 tcp/13720 tcp/13721 tcp/13724 tcp/13782 tcp/13783"
  637. client_netbackup_ports="any"
  638.  
  639. server_netbios_ns_ports="udp/137"
  640. client_netbios_ns_ports="default 137"
  641.  
  642. server_netbios_dgm_ports="udp/138"
  643. client_netbios_dgm_ports="default 138"
  644.  
  645. server_netbios_ssn_ports="tcp/139"
  646. client_netbios_ssn_ports="default"
  647.  
  648. server_nntp_ports="tcp/119"
  649. client_nntp_ports="default"
  650.  
  651. server_nntps_ports="tcp/563"
  652. client_nntps_ports="default"
  653.  
  654. server_ntp_ports="udp/123 tcp/123"
  655. client_ntp_ports="123 default"
  656.  
  657. # Network UPS Tools
  658. server_nut_ports="tcp/3493 udp/3493"
  659. client_nut_ports="default"
  660.  
  661. # NoMachine's NX server
  662. server_nxserver_ports="tcp/5000:5200"
  663. client_nxserver_ports="default"
  664.  
  665. # Oracle database
  666. server_oracle_ports="tcp/1521"
  667. client_oracle_ports="default"
  668.  
  669. server_pop3_ports="tcp/110"
  670. client_pop3_ports="default"
  671.  
  672. server_pop3s_ports="tcp/995"
  673. client_pop3s_ports="default"
  674.  
  675. # Portmap clients appear to use ports bellow 1024
  676. server_portmap_ports="udp/111 tcp/111"
  677. client_portmap_ports="500:65535"
  678.  
  679. server_postgres_ports="tcp/5432"
  680. client_postgres_ports="default"
  681.  
  682. # Privacy Proxy
  683. server_privoxy_ports="tcp/8118"
  684. client_privoxy_ports="default"
  685.  
  686. server_radius_ports="udp/1812 udp/1813"
  687. client_radius_ports="default"
  688.  
  689. server_radiusproxy_ports="udp/1814"
  690. client_radiusproxy_ports="default"
  691.  
  692. server_radiusold_ports="udp/1645 udp/1646"
  693. client_radiusold_ports="default"
  694.  
  695. server_radiusoldproxy_ports="udp/1647"
  696. client_radiusoldproxy_ports="default"
  697.  
  698. server_rdp_ports="tcp/3389"
  699. client_rdp_ports="default"
  700.  
  701. server_rndc_ports="tcp/953"
  702. client_rndc_ports="default"
  703.  
  704. server_rsync_ports="tcp/873 udp/873"
  705. client_rsync_ports="default"
  706.  
  707. server_rtp_ports="udp/10000:20000"
  708. client_rtp_ports="any"
  709.  
  710. server_sip_ports="udp/5060"
  711. client_sip_ports="default"
  712.  
  713. server_socks_ports="tcp/1080 udp/1080"
  714. client_socks_ports="default"
  715.  
  716. server_squid_ports="tcp/3128"
  717. client_squid_ports="default"
  718.  
  719. server_smtp_ports="tcp/25"
  720. client_smtp_ports="default"
  721.  
  722. server_smtps_ports="tcp/465"
  723. client_smtps_ports="default"
  724.  
  725. server_snmp_ports="udp/161"
  726. client_snmp_ports="default"
  727.  
  728. server_snmptrap_ports="udp/162"
  729. client_snmptrap_ports="any"
  730.  
  731. server_ssh_ports="tcp/22"
  732. client_ssh_ports="default"
  733.  
  734. server_stun_ports="udp/3478 udp/3479"
  735. client_stun_ports="any"
  736.  
  737. # SMTP over SSL/TLS submission
  738. server_submission_ports="tcp/587"
  739. client_submission_ports="default"
  740.  
  741. # Sun RCP is an alias for service portmap
  742. server_sunrpc_ports="${server_portmap_ports}"
  743. client_sunrpc_ports="${client_portmap_ports}"
  744.  
  745. server_swat_ports="tcp/901"
  746. client_swat_ports="default"
  747.  
  748. server_syslog_ports="udp/514"
  749. client_syslog_ports="syslog default"
  750.  
  751. server_telnet_ports="tcp/23"
  752. client_telnet_ports="default"
  753.  
  754. server_time_ports="tcp/37 udp/37"
  755. client_time_ports="default"
  756.  
  757. server_upnp_ports="udp/1900 tcp/2869"
  758. client_upnp_ports="default"
  759.  
  760. server_uucp_ports="tcp/540"
  761. client_uucp_ports="default"
  762.  
  763. server_whois_ports="tcp/43"
  764. client_whois_ports="default"
  765.  
  766. server_vmware_ports="tcp/902"
  767. client_vmware_ports="default"
  768.  
  769. server_vmwareauth_ports="tcp/903"
  770. client_vmwareauth_ports="default"
  771.  
  772. server_vmwareweb_ports="tcp/8222"
  773. client_vmwareweb_ports="default"
  774.  
  775. server_vnc_ports="tcp/5900:5903"
  776. client_vnc_ports="default"
  777.  
  778. server_webcache_ports="tcp/8080"
  779. client_webcache_ports="default"
  780.  
  781. server_webmin_ports="tcp/10000"
  782. client_webmin_ports="default"
  783.  
  784. server_xdmcp_ports="udp/177"
  785. client_xdmcp_ports="default"
  786.  
  787.  
  788. # ------------------------------------------------------------------------------
  789. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  790. # ------------------------------------------------------------------------------
  791. #
  792. # COMPLEX SERVICES DEFINITIONS
  793. #
  794. # ------------------------------------------------------------------------------
  795. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  796. # ------------------------------------------------------------------------------
  797. # The following are definitions for complex services.
  798. # We define as "complex" the services that are implemented using multiple sockets.
  799.  
  800. # Each function bellow is organized in three parts:
  801. # 1) A Header, common to each and every function
  802. # 2) The rules required for the INPUT of the server
  803. # 3) The rules required for the OUTPUT of the server
  804. #
  805. # The Header part, together with the "reverse" keyword can reverse the rules so
  806. # that if we are implementing a client the INPUT will become OUTPUT and vice versa.
  807. #
  808. # In most the cases the input and output rules are the same with the following
  809. # differences:
  810. #
  811. # a) The output rules begin with the "reverse" keyword, which reverses:
  812. #    inface/outface, src/dst, sport/dport
  813. # b) The output rules use ${out}_${mychain} instead of ${in}_${mychain}
  814. # c) The state rules match the client operation, not the server.
  815.  
  816.  
  817. # --- DHCP --------------------------------------------------------------------
  818.  
  819. rules_dhcp() {
  820.         local mychain="${1}"; shift
  821.     local type="${1}"; shift
  822.     
  823.     local in=in
  824.     local out=out
  825.     if [ "${type}" = "client" ]
  826.     then
  827.         in=out
  828.         out=in
  829.     fi
  830.     
  831.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  832.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  833.     then
  834.         client_ports="${LOCAL_CLIENT_PORTS}"
  835.     fi
  836.     
  837.     # ----------------------------------------------------------------------
  838.     
  839.     set_work_function "Setting up rules for DHCP (${type})"
  840.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "udp" sport "68" dport "67" || return 1
  841.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "udp" sport "68" dport "67" || return 1
  842.     
  843.     return 0
  844. }
  845.  
  846.  
  847. # --- EMULE --------------------------------------------------------------------
  848.  
  849. rules_emule() {
  850.         local mychain="${1}"; shift
  851.     local type="${1}"; shift
  852.     
  853.     local in=in
  854.     local out=out
  855.     if [ "${type}" = "client" ]
  856.     then
  857.         in=out
  858.         out=in
  859.     fi
  860.     
  861.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  862.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  863.     then
  864.         client_ports="${LOCAL_CLIENT_PORTS}"
  865.     fi
  866.     
  867.     # ----------------------------------------------------------------------
  868.     
  869.     # allow incomming to server tcp/4662
  870.     set_work_function "Setting up rules for EMULE/client-to-server tcp/4662 (${type})"
  871.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "tcp" sport any dport 4662 state NEW,ESTABLISHED || return 1
  872.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "tcp" sport any dport 4662 state ESTABLISHED     || return 1
  873.     
  874.     # allow outgoing to client tcp/4662
  875.     set_work_function "Setting up rules for EMULE/server-to-client tcp/4662 (${type})"
  876.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "tcp" dport any sport 4662 state NEW,ESTABLISHED || return 1
  877.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "tcp" dport any sport 4662 state ESTABLISHED     || return 1
  878.     
  879.     # allow incomming to server udp/4672
  880.     set_work_function "Setting up rules for EMULE/client-to-server udp/4672 (${type})"
  881.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "udp" sport any dport 4672 state NEW,ESTABLISHED || return 1
  882.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "udp" sport any dport 4672 state ESTABLISHED     || return 1
  883.     
  884.     # allow outgoing to client udp/4672
  885.     set_work_function "Setting up rules for EMULE/server-to-client udp/4672 (${type})"
  886.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "udp" dport any sport 4672 state NEW,ESTABLISHED || return 1
  887.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "udp" dport any sport 4672 state ESTABLISHED     || return 1
  888.     
  889.     # allow incomming to server tcp/4661
  890.     set_work_function "Setting up rules for EMULE/client-to-server tcp/4661 (${type})"
  891.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "tcp" sport any dport 4661 state NEW,ESTABLISHED || return 1
  892.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "tcp" sport any dport 4661 state ESTABLISHED     || return 1
  893.     
  894.     # allow incomming to server udp/4665
  895.     set_work_function "Setting up rules for EMULE/client-to-server udp/4665 (${type})"
  896.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "udp" sport any dport 4665 state NEW,ESTABLISHED || return 1
  897.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "udp" sport any dport 4665 state ESTABLISHED     || return 1
  898.     
  899.     return 0
  900. }
  901.  
  902.  
  903. # --- HYLAFAX ------------------------------------------------------------------
  904. # Written by: Franscisco Javier Felix <ffelix@gescosoft.com>
  905.  
  906. rules_hylafax() {
  907.         local mychain="${1}"; shift
  908.     local type="${1}"; shift
  909.     
  910.     local in=in
  911.     local out=out
  912.     if [ "${type}" = "client" ]
  913.     then
  914.         in=out
  915.         out=in
  916.     fi
  917.     
  918.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  919.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  920.     then
  921.         client_ports="${LOCAL_CLIENT_PORTS}"
  922.     fi
  923.     
  924.     # ----------------------------------------------------------------------
  925.     
  926.     # allow incomming to server tcp/4559
  927.     set_work_function "Setting up rules for HYLAFAX/client-to-server tcp/4559 (${type})"
  928.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "tcp" sport any dport 4559 state NEW,ESTABLISHED || return 1
  929.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "tcp" sport any dport 4559 state ESTABLISHED     || return 1
  930.     
  931.     # allow outgoing to client from server tcp/4558
  932.     set_work_function "Setting up rules for HYLAFAX/server-to-client from server tcp/4558 (${type})"
  933.     rule ${out}        action "$@" chain "${out}_${mychain}" proto "tcp" sport 4558 dport any state NEW,ESTABLISHED || return 1
  934.         rule ${in} reverse action "$@" chain "${in}_${mychain}"  proto "tcp" sport 4558 dport any state ESTABLISHED     || return 1
  935.     
  936.     return 0
  937. }
  938.  
  939.  
  940. # --- SAMBA --------------------------------------------------------------------
  941.  
  942. rules_samba() {
  943.         local mychain="${1}"; shift
  944.     local type="${1}"; shift
  945.     
  946.     local in=in
  947.     local out=out
  948.     if [ "${type}" = "client" ]
  949.     then
  950.         in=out
  951.         out=in
  952.     fi
  953.     
  954.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  955.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  956.     then
  957.         client_ports="${LOCAL_CLIENT_PORTS}"
  958.     fi
  959.     
  960.     # ----------------------------------------------------------------------
  961.     
  962.     set_work_function "Setting up rules for SAMBA/NETBIOS-NS (${type})"
  963.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "udp" sport "137 ${client_ports}"  dport 137 state NEW,ESTABLISHED || return 1
  964.     
  965.     # NETBIOS initiates based on the broadcast address of an interface
  966.     # (request goes to broadcast address) but the server responds from
  967.     # its own IP address. This makes the server samba accept statement
  968.     # drop the server reply.
  969.     # Bellow is a hack, that allows a linux samba server to respond
  970.     # correctly, as it allows new outgoing connections from the well
  971.     # known netbios-ns port to the clients high ports.
  972.     # For clients and routers this hack is not applied because it
  973.     # would be a huge security hole.
  974.     if [ "${type}" = "server" -a "${work_cmd}" = "interface" ]
  975.     then
  976.         rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "udp" sport "137 ${client_ports}"  dport 137 state NEW,ESTABLISHED || return 1
  977.     else
  978.         rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "udp" sport "137 ${client_ports}"  dport 137 state ESTABLISHED     || return 1
  979.     fi
  980.     
  981.     set_work_function "Setting up rules for SAMBA/NETBIOS-DGM (${type})"
  982.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "udp" sport "138 ${client_ports}" dport 138 state NEW,ESTABLISHED || return 1
  983.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "udp" sport "138 ${client_ports}" dport 138 state ESTABLISHED     || return 1
  984.     
  985.     set_work_function "Setting up rules for SAMBA/NETBIOS-SSN (${type})"
  986.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "tcp" sport "${client_ports}" dport 139 state NEW,ESTABLISHED || return 1
  987.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "tcp" sport "${client_ports}" dport 139 state ESTABLISHED     || return 1
  988.     
  989.     set_work_function "Setting up rules for SAMBA/MICROSOFT_DS (${type})"
  990.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "tcp" sport "${client_ports}" dport 445 state NEW,ESTABLISHED || return 1
  991.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "tcp" sport "${client_ports}" dport 445 state ESTABLISHED     || return 1
  992.     
  993.     return 0
  994. }
  995.  
  996.  
  997. # --- PPTP --------------------------------------------------------------------
  998.  
  999. rules_pptp() {
  1000.         local mychain="${1}"; shift
  1001.     local type="${1}"; shift
  1002.     
  1003.     local in=in
  1004.     local out=out
  1005.     if [ "${type}" = "client" ]
  1006.     then
  1007.         in=out
  1008.         out=in
  1009.     fi
  1010.     
  1011.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1012.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1013.     then
  1014.         client_ports="${LOCAL_CLIENT_PORTS}"
  1015.     fi
  1016.     
  1017.     # ----------------------------------------------------------------------
  1018.     
  1019.     set_work_function "Setting up rules for PPTP/initial connection (${type})"
  1020.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "tcp" sport "${client_ports}" dport "1723" state NEW,ESTABLISHED || return 1
  1021.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "tcp" sport "${client_ports}" dport "1723" state ESTABLISHED     || return 1
  1022.     
  1023.     set_work_function "Setting up rules for PPTP/tunnel GRE traffic (${type})"
  1024.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "47"    || return 1
  1025.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "47"    || return 1
  1026.     
  1027.     return 0
  1028. }
  1029.  
  1030.  
  1031. # --- NFS ----------------------------------------------------------------------
  1032.  
  1033. rules_nfs() {
  1034.         local mychain="${1}"; shift
  1035.     local type="${1}"; shift
  1036.     
  1037.     local in=in
  1038.     local out=out
  1039.     if [ "${type}" = "client" ]
  1040.     then
  1041.         in=out
  1042.         out=in
  1043.     fi
  1044.     
  1045.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1046.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1047.     then
  1048.         client_ports="${LOCAL_CLIENT_PORTS}"
  1049.     fi
  1050.     
  1051.     # ----------------------------------------------------------------------
  1052.     
  1053.     # This command requires in the client or route subcommands,
  1054.     # the first argument after the policy/action is a dst.
  1055.     
  1056.     local action="${1}"; shift
  1057.     local servers="localhost"
  1058.     
  1059.     if [ "${type}" = "client" -o ! "${work_cmd}" = "interface" ]
  1060.     then
  1061.         case "${1}" in
  1062.             dst|DST|destination|DESTINATION)
  1063.                 shift
  1064.                 local servers="${1}"
  1065.                 shift
  1066.                 ;;
  1067.                 
  1068.             *)
  1069.                 error "Please re-phrase to: ${type} nfs ${action} dst <NFS_SERVER> [other rules]"
  1070.                 return 1
  1071.                 ;;
  1072.         esac
  1073.     fi
  1074.     
  1075.     local x=
  1076.     for x in ${servers}
  1077.     do
  1078.         local tmp="${FIREHOL_DIR}/firehol.rpcinfo.$$.${RANDOM}"
  1079.         
  1080.         set_work_function "Getting RPC information from server '${x}'"
  1081.         
  1082.         rpcinfo -p ${x} >"${tmp}"
  1083.         if [ $? -gt 0 -o ! -s "${tmp}" ]
  1084.         then
  1085.             error "Cannot get rpcinfo from host '${x}' (using the previous firewall rules)"
  1086.             ${RM_CMD} -f "${tmp}"
  1087.             return 1
  1088.         fi
  1089.         
  1090.         local server_rquotad_ports="`${CAT_CMD} "${tmp}" | ${GREP_CMD} " rquotad$"  | ( while read a b proto port s; do echo "$proto/$port"; done ) | ${SORT_CMD} | ${UNIQ_CMD}`"
  1091.         local server_mountd_ports="`${CAT_CMD} "${tmp}" | ${GREP_CMD} " mountd$"  | ( while read a b proto port s; do echo "$proto/$port"; done ) | ${SORT_CMD} | ${UNIQ_CMD}`"
  1092.         local server_lockd_ports="`${CAT_CMD} "${tmp}" | ${GREP_CMD} " nlockmgr$" | ( while read a b proto port s; do echo "$proto/$port"; done ) | ${SORT_CMD} | ${UNIQ_CMD}`"
  1093.         local server_nfsd_ports="`${CAT_CMD} "${tmp}" | ${GREP_CMD} " nfs$"       | ( while read a b proto port s; do echo "$proto/$port"; done ) | ${SORT_CMD} | ${UNIQ_CMD}`"
  1094.         
  1095.         test -z "${server_mountd_ports}" && error "Cannot find mountd ports for nfs server '${x}'" && return 1
  1096.         test -z "${server_lockd_ports}"  && error "Cannot find lockd ports for nfs server '${x}'" && return 1
  1097.         test -z "${server_nfsd_ports}"   && error "Cannot find nfsd ports for nfs server '${x}'" && return 1
  1098.         
  1099.         local dst=
  1100.         if [ ! "${x}" = "localhost" ]
  1101.         then
  1102.             dst="dst ${x}"
  1103.         fi
  1104.         
  1105.         if [ ! -z "${server_rquotad_ports}" ]
  1106.         then
  1107.             set_work_function "Processing rquotad rules for server '${x}'"
  1108.             rules_custom "${mychain}" "${type}" nfs-rquotad "${server_rquotad_ports}" "500:65535" "${action}" $dst "$@"
  1109.         fi
  1110.         
  1111.         set_work_function "Processing mountd rules for server '${x}'"
  1112.         rules_custom "${mychain}" "${type}" nfs-mountd "${server_mountd_ports}" "500:65535" "${action}" $dst "$@"
  1113.         
  1114.         set_work_function "Processing lockd rules for server '${x}'"
  1115.         rules_custom "${mychain}" "${type}" nfs-lockd "${server_lockd_ports}" "500:65535" "${action}" $dst "$@"
  1116.         
  1117.         set_work_function "Processing nfsd rules for server '${x}'"
  1118.         rules_custom "${mychain}" "${type}" nfs-nfsd   "${server_nfsd_ports}"   "500:65535" "${action}" $dst "$@"
  1119.         
  1120.         ${RM_CMD} -f "${tmp}"
  1121.         
  1122.         echo >&2 ""
  1123.         echo >&2 "WARNING:"
  1124.         echo >&2 "This firewall must be restarted if NFS server ${x} is restarted!"
  1125.         echo >&2 ""
  1126.     done
  1127.     
  1128.     return 0
  1129. }
  1130.  
  1131.  
  1132. # --- NIS ----------------------------------------------------------------------
  1133. # These rules work for client access only!
  1134. #
  1135. # Pushing changes to slave servers won't work if these rules are active
  1136. # somewhere between the master and its slaves, because it is impossible to
  1137. # predict the ports where "yppush" will be listening on each push.
  1138. #
  1139. # Pulling changes directly on the slaves will work, and could be improved
  1140. # performance-wise if these rules are modified to open "fypxfrd". This wasn't
  1141. # done because it doesn't make that much sense since pushing changes on the
  1142. # master server is the most common, and recommended, way to replicate maps.
  1143. #
  1144. # Created by Carlos Rodrigues <crlf@users.sourceforge.net>
  1145. # Feature Requests item #1050951 <https://sourceforge.net/tracker/?func=detail&atid=487695&aid=1050951&group_id=58425>
  1146.  
  1147. rules_nis() {
  1148.         local mychain="${1}"; shift
  1149.     local type="${1}"; shift
  1150.     
  1151.     local in=in
  1152.     local out=out
  1153.     if [ "${type}" = "client" ]
  1154.     then
  1155.         in=out
  1156.         out=in
  1157.     fi
  1158.     
  1159.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1160.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1161.     then
  1162.         client_ports="${LOCAL_CLIENT_PORTS}"
  1163.     fi
  1164.     
  1165.     # ----------------------------------------------------------------------
  1166.     
  1167.     # This command requires in the client or route subcommands,
  1168.     # the first argument after the policy/action is a dst.
  1169.     
  1170.     local action="${1}"; shift
  1171.     local servers="localhost"
  1172.     
  1173.     if [ "${type}" = "client" -o ! "${work_cmd}" = "interface" ]
  1174.     then
  1175.         case "${1}" in
  1176.             dst|DST|destination|DESTINATION)
  1177.                 shift
  1178.                 local servers="${1}"
  1179.                 shift
  1180.                 ;;
  1181.                 
  1182.             *)
  1183.                 error "Please re-phrase to: ${type} nis ${action} dst <NIS_SERVER> [other rules]"
  1184.                 return 1
  1185.                 ;;
  1186.         esac
  1187.     fi
  1188.     
  1189.     local x=
  1190.     for x in ${servers}
  1191.     do
  1192.         local tmp="${FIREHOL_DIR}/firehol.rpcinfo.$$.${RANDOM}"
  1193.         
  1194.         set_work_function "Getting RPC information from server '${x}'"
  1195.         
  1196.         rpcinfo -p ${x} >"${tmp}"
  1197.         if [ $? -gt 0 -o ! -s "${tmp}" ]
  1198.         then
  1199.             error "Cannot get rpcinfo from host '${x}' (using the previous firewall rules)"
  1200.             ${RM_CMD} -f "${tmp}"
  1201.             return 1
  1202.         fi
  1203.         
  1204.         local server_ypserv_ports="`${CAT_CMD} "${tmp}" | ${GREP_CMD} " ypserv$"  | ( while read a b proto port s; do echo "$proto/$port"; done ) | ${SORT_CMD} | ${UNIQ_CMD}`"
  1205.         local server_yppasswdd_ports="`${CAT_CMD} "${tmp}" | ${GREP_CMD} " yppasswdd$"  | ( while read a b proto port s; do echo "$proto/$port"; done ) | ${SORT_CMD} | ${UNIQ_CMD}`"
  1206.         
  1207.         test -z "${server_ypserv_ports}" && error "Cannot find ypserv ports for nis server '${x}'" && return 1
  1208.         
  1209.         local dst=
  1210.         if [ ! "${x}" = "localhost" ]
  1211.         then
  1212.             dst="dst ${x}"
  1213.         fi
  1214.         
  1215.         if [ ! -z "${server_yppasswd_ports}" ]
  1216.         then
  1217.             set_work_function "Processing yppasswd rules for server '${x}'"
  1218.             rules_custom "${mychain}" "${type}" nis-yppasswd "${server_yppasswdd_ports}" "500:65535" "${action}" $dst "$@"
  1219.         fi
  1220.         
  1221.         set_work_function "Processing ypserv rules for server '${x}'"
  1222.         rules_custom "${mychain}" "${type}" nis-ypserv "${server_ypserv_ports}" "500:65535" "${action}" $dst "$@"
  1223.         
  1224.         ${RM_CMD} -f "${tmp}"
  1225.         
  1226.         echo >&2 ""
  1227.         echo >&2 "WARNING:"
  1228.         echo >&2 "This firewall must be restarted if NIS server ${x} is restarted!"
  1229.         echo >&2 ""
  1230.     done
  1231.     
  1232.     return 0
  1233. }
  1234.  
  1235.  
  1236. # --- AMANDA -------------------------------------------------------------------
  1237. FIREHOL_AMANDA_PORTS="850:859"
  1238.  
  1239. rules_amanda() {
  1240.         local mychain="${1}"; shift
  1241.     local type="${1}"; shift
  1242.     
  1243.     local in=in
  1244.     local out=out
  1245.     if [ "${type}" = "client" ]
  1246.     then
  1247.         in=out
  1248.         out=in
  1249.     fi
  1250.     
  1251.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1252.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1253.     then
  1254.         client_ports="${LOCAL_CLIENT_PORTS}"
  1255.     fi
  1256.     
  1257.     # ----------------------------------------------------------------------
  1258.     
  1259.     set_work_function "*** AMANDA: See http://amanda.sourceforge.net/fom-serve/cache/139.html"
  1260.     
  1261.     
  1262.     set_work_function "Setting up rules for initial amanda server-to-client connection"
  1263.     rule ${out}        action "$@" chain "${out}_${mychain}" proto "udp" dport 10080 state NEW,ESTABLISHED || return 1
  1264.     rule ${in} reverse action "$@" chain "${in}_${mychain}"  proto "udp" dport 10080 state ESTABLISHED     || return 1
  1265.     
  1266.     
  1267.     set_work_function "Setting up rules for amanda data exchange client-to-server"
  1268.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "tcp udp" dport "${FIREHOL_AMANDA_PORTS}" state NEW,ESTABLISHED || return 1
  1269.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "tcp udp" dport "${FIREHOL_AMANDA_PORTS}" state ESTABLISHED     || return 1
  1270.     
  1271.     return 0
  1272. }
  1273.  
  1274. # --- FTP ----------------------------------------------------------------------
  1275.  
  1276. ALL_SHOULD_ALSO_RUN="${ALL_SHOULD_ALSO_RUN} ftp"
  1277.  
  1278. rules_ftp() {
  1279.         local mychain="${1}"; shift
  1280.     local type="${1}"; shift
  1281.     
  1282.     local in=in
  1283.     local out=out
  1284.     if [ "${type}" = "client" ]
  1285.     then
  1286.         in=out
  1287.         out=in
  1288.     fi
  1289.     
  1290.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1291.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1292.     then
  1293.         client_ports="${LOCAL_CLIENT_PORTS}"
  1294.     fi
  1295.     
  1296.     # For an explanation of how FTP connections work, see
  1297.     # http://slacksite.com/other/ftp.html
  1298.     
  1299.     # ----------------------------------------------------------------------
  1300.     
  1301.     # allow new and established incoming, and established outgoing
  1302.     # accept port ftp new connections
  1303.     set_work_function "Setting up rules for initial FTP connection ${type}"
  1304.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto tcp sport "${client_ports}" dport ftp state NEW,ESTABLISHED || return 1
  1305.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto tcp sport "${client_ports}" dport ftp state ESTABLISHED     || return 1
  1306.     
  1307.     # Active FTP
  1308.     # send port ftp-data related connections
  1309.     set_work_function "Setting up rules for Active FTP ${type}"
  1310.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto tcp sport "${client_ports}" dport ftp-data state ESTABLISHED,RELATED || return 1
  1311.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto tcp sport "${client_ports}" dport ftp-data state ESTABLISHED         || return 1
  1312.     
  1313.     # ----------------------------------------------------------------------
  1314.     
  1315.     # A hack for Passive FTP only
  1316.     local s_client_ports="${DEFAULT_CLIENT_PORTS}"
  1317.     local c_client_ports="${DEFAULT_CLIENT_PORTS}"
  1318.     
  1319.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1320.     then
  1321.         c_client_ports="${LOCAL_CLIENT_PORTS}"
  1322.     elif [ "${type}" = "server" -a "${work_cmd}" = "interface" ]
  1323.     then
  1324.         s_client_ports="${LOCAL_CLIENT_PORTS}"
  1325.     fi
  1326.     
  1327.     # Passive FTP
  1328.     # accept high-ports related connections
  1329.     set_work_function "Setting up rules for Passive FTP ${type}"
  1330.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto tcp sport "${c_client_ports}" dport "${s_client_ports}" state ESTABLISHED,RELATED || return 1
  1331.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto tcp sport "${c_client_ports}" dport "${s_client_ports}" state ESTABLISHED         || return 1
  1332.     
  1333.     require_kernel_module ip_conntrack_ftp
  1334.     test ${FIREHOL_NAT} -eq 1 && require_kernel_module ip_nat_ftp
  1335.     
  1336.     return 0
  1337. }
  1338.  
  1339.  
  1340. # --- TFTP ---------------------------------------------------------------------
  1341. # Written by: Goetz Bock <bock@blacknet.de>
  1342.  
  1343. rules_tftp() {
  1344.     local mychain="${1}"; shift
  1345.     local type="${1}"; shift
  1346.     
  1347.     local in=in
  1348.     local out=out
  1349.     if [ "${type}" = "client" ]
  1350.     then
  1351.         in=out
  1352.         out=in
  1353.     fi
  1354.     
  1355.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1356.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1357.     then
  1358.         client_ports="${LOCAL_CLIENT_PORTS}"
  1359.     fi
  1360.     
  1361.     # ---------------------------------------------------------------------
  1362.     # TFTP is a broken protokol. It works like this:
  1363.     #
  1364.     # 1. The client sends from a high port (a) to the server's tftp port an
  1365.     #    udp packet with "give me file 'bla'".
  1366.     #
  1367.     # 2. The server replies from a high port (b) to the highport the client
  1368.     #    used (a) with "this is part 0 if your file"
  1369.     #
  1370.     # 3. The client now has to send a reply (from his highport a) to the
  1371.     #    servers high port (b): "got part 0, send next part 1".
  1372.     #
  1373.     # 4. repeat 2. and 3. till file transmitted
  1374.     
  1375.     # allow the initial TFTP connection
  1376.     set_work_function "Setting up rules for initial TFTP connection (${type})"
  1377.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "udp" sport "${client_ports}" dport tftp state NEW,ESTABLISHED || return 1
  1378. #    rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "udp" sport "${client_ports}" dport tftp state ESTABLISHED     || return 1
  1379.     
  1380.     # We now need both server and client port ranges
  1381.     local s_client_ports="${DEFAULT_CLIENT_PORTS}"
  1382.     local c_client_ports="${DEFAULT_CLIENT_PORTS}"
  1383.     
  1384.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1385.     then
  1386.         c_client_ports="${LOCAL_CLIENT_PORTS}"
  1387.     elif [ "${type}" = "server" -a "${work_cmd}" = "interface" ]
  1388.     then
  1389.         s_client_ports="${LOCAL_CLIENT_PORTS}"
  1390.     fi
  1391.     
  1392.     # allow the TFTP server to establish a new connection to the client
  1393.     set_work_function "Setting up rules for server-to-client TFTP connection (${type})"
  1394.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "udp" sport "${c_client_ports}" dport "${s_client_ports}" state RELATED,ESTABLISHED || return 1
  1395.     rule ${in}          action "$@" chain "${in}_${mychain}"  proto "udp" sport "${c_client_ports}" dport "${s_client_ports}" state ESTABLISHED         || return 1
  1396.     
  1397.     require_kernel_module ip_conntrack_tftp
  1398.     test ${FIREHOL_NAT} -eq 1 && require_kernel_module ip_nat_tftp
  1399.     
  1400.     return 0
  1401. }
  1402.  
  1403.  
  1404. # --- PING ---------------------------------------------------------------------
  1405.  
  1406. rules_ping() {
  1407.         local mychain="${1}"; shift
  1408.     local type="${1}"; shift
  1409.     
  1410.     local in=in
  1411.     local out=out
  1412.     if [ "${type}" = "client" ]
  1413.     then
  1414.         in=out
  1415.         out=in
  1416.     fi
  1417.     
  1418.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1419.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1420.     then
  1421.         client_ports="${LOCAL_CLIENT_PORTS}"
  1422.     fi
  1423.     
  1424.     # ----------------------------------------------------------------------
  1425.     
  1426.     # allow incoming new and established PING packets
  1427.     rule ${in} action "$@" chain "${in}_${mychain}" proto icmp custom "--icmp-type echo-request" state NEW,ESTABLISHED || return 1
  1428.     
  1429.     # allow outgoing established packets
  1430.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto icmp custom "--icmp-type echo-reply" state ESTABLISHED || return 1
  1431.     
  1432.     return 0
  1433. }
  1434.  
  1435. # --- TIMESTAMP ----------------------------------------------------------------
  1436.  
  1437. rules_timestamp() {
  1438.         local mychain="${1}"; shift
  1439.     local type="${1}"; shift
  1440.     
  1441.     local in=in
  1442.     local out=out
  1443.     if [ "${type}" = "client" ]
  1444.     then
  1445.         in=out
  1446.         out=in
  1447.     fi
  1448.     
  1449.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1450.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1451.     then
  1452.         client_ports="${LOCAL_CLIENT_PORTS}"
  1453.     fi
  1454.     
  1455.     # ----------------------------------------------------------------------
  1456.     
  1457.     # allow incoming new and established PING packets
  1458.     rule ${in} action "$@" chain "${in}_${mychain}" proto icmp custom "--icmp-type timestamp-request" state NEW,ESTABLISHED || return 1
  1459.     
  1460.     # allow outgoing established packets
  1461.     rule ${out} reverse action "$@" chain "${out}_${mychain}" proto icmp custom "--icmp-type timestamp-reply" state ESTABLISHED || return 1
  1462.     
  1463.     return 0
  1464. }
  1465.  
  1466.  
  1467. # --- P2P ----------------------------------------------------------------------
  1468.  
  1469. rules_p2p() {
  1470.         local mychain="${1}"; shift
  1471.     local type="${1}"; shift
  1472.     
  1473.     local in=in
  1474.     local out=out
  1475.     if [ "${type}" = "client" ]
  1476.     then
  1477.         in=out
  1478.         out=in
  1479.     fi
  1480.     
  1481.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1482.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1483.     then
  1484.         client_ports="${LOCAL_CLIENT_PORTS}"
  1485.     fi
  1486.     
  1487.     # ----------------------------------------------------------------------
  1488.     
  1489.     # Remove the action from the arguments.
  1490.     shift
  1491.     
  1492.     do_in() {
  1493.         # allow new and established incoming packets
  1494.         rule ${in} action "$@" chain "${in}_${mychain}" state NEW,ESTABLISHED || return 1
  1495.     }
  1496.     
  1497.     do_out() {
  1498.         # allow outgoing established packets
  1499.         rule ${out} reverse action "$@" chain "${out}_${mychain}" state NEW,ESTABLISHED || return 1
  1500.     }
  1501.     
  1502.     # Kazaa
  1503.     # Check: http://www.derkeiler.com/Mailing-Lists/Firewall-Wizards/2003-06/0152.html
  1504.     # New clients will try to use port 80 - use a proxy to filter this too.
  1505.     set_work_function "Setting up rules for Kazaa (${type})"
  1506.     do_in  drop "$@" proto "tcp udp" sport 1214
  1507.     do_in  drop "$@" proto "tcp udp" dport 1214
  1508.     do_out drop "$@" proto "tcp udp" dport 1214
  1509.     do_out drop "$@" proto "tcp udp" sport 1214
  1510.     
  1511.     # Gnutella
  1512.     
  1513.     # Mldonkey
  1514.     
  1515.     # Emule
  1516.     
  1517.     # audiogalaxy
  1518.     
  1519.     # hotline
  1520.     
  1521.     
  1522.     return 0
  1523. }
  1524.  
  1525.  
  1526. # --- ALL ----------------------------------------------------------------------
  1527.  
  1528. rules_all() {
  1529.         local mychain="${1}"; shift
  1530.     local type="${1}"; shift
  1531.     
  1532.     local in=in
  1533.     local out=out
  1534.     if [ "${type}" = "client" ]
  1535.     then
  1536.         in=out
  1537.         out=in
  1538.     fi
  1539.     
  1540.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1541.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1542.     then
  1543.         client_ports="${LOCAL_CLIENT_PORTS}"
  1544.     fi
  1545.     
  1546.     # ----------------------------------------------------------------------
  1547.     
  1548.     # allow new and established incoming packets
  1549.     rule ${in} action "$@" chain "${in}_${mychain}" state NEW,ESTABLISHED || return 1
  1550.     
  1551.     # allow outgoing established packets
  1552.     rule ${out} reverse action "$@" chain "${out}_${mychain}" state ESTABLISHED || return 1
  1553.     
  1554.     local ser=
  1555.     for ser in ${ALL_SHOULD_ALSO_RUN}
  1556.     do
  1557.         "${type}" ${ser} "$@" || return 1
  1558.     done
  1559.     
  1560.     return 0
  1561. }
  1562.  
  1563.  
  1564. # --- ANY ----------------------------------------------------------------------
  1565.  
  1566. rules_any() {
  1567.         local mychain="${1}"; shift
  1568.     local type="${1}"; shift
  1569.     local name="${1}"; shift # a special case: service any gets a name
  1570.     
  1571.     local in=in
  1572.     local out=out
  1573.     if [ "${type}" = "client" ]
  1574.     then
  1575.         in=out
  1576.         out=in
  1577.     fi
  1578.     
  1579.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1580.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1581.     then
  1582.         client_ports="${LOCAL_CLIENT_PORTS}"
  1583.     fi
  1584.     
  1585.     # ----------------------------------------------------------------------
  1586.     
  1587.     # allow new and established incoming packets
  1588.     rule ${in} action "$@" chain "${in}_${mychain}" state NEW,ESTABLISHED || return 1
  1589.     
  1590.     # allow outgoing established packets
  1591.     rule ${out} reverse action "$@" chain "${out}_${mychain}" state ESTABLISHED || return 1
  1592.     
  1593.     return 0
  1594. }
  1595.  
  1596.  
  1597. # --- ANYSTATELESS -------------------------------------------------------------
  1598.  
  1599. rules_anystateless() {
  1600.         local mychain="${1}"; shift
  1601.     local type="${1}"; shift
  1602.     local name="${1}"; shift # a special case: service any gets a name
  1603.     
  1604.     local in=in
  1605.     local out=out
  1606.     if [ "${type}" = "client" ]
  1607.     then
  1608.         in=out
  1609.         out=in
  1610.     fi
  1611.     
  1612.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1613.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1614.     then
  1615.         client_ports="${LOCAL_CLIENT_PORTS}"
  1616.     fi
  1617.     
  1618.     # ----------------------------------------------------------------------
  1619.     
  1620.     # allow new and established incoming packets
  1621.     rule ${in} action "$@" chain "${in}_${mychain}" || return 1
  1622.     
  1623.     # allow outgoing established packets
  1624.     rule ${out} reverse action "$@" chain "${out}_${mychain}" || return 1
  1625.     
  1626.     return 0
  1627. }
  1628.  
  1629.  
  1630. # --- MULTICAST ----------------------------------------------------------------
  1631.  
  1632. rules_multicast() {
  1633.         local mychain="${1}"; shift
  1634.     local type="${1}"; shift
  1635.     
  1636.     local in=in
  1637.     local out=out
  1638.     if [ "${type}" = "client" ]
  1639.     then
  1640.         in=out
  1641.         out=in
  1642.     fi
  1643.     
  1644.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1645.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1646.     then
  1647.         client_ports="${LOCAL_CLIENT_PORTS}"
  1648.     fi
  1649.     
  1650.     # ----------------------------------------------------------------------
  1651.     
  1652.     # match multicast packets in both directions
  1653.     rule ${out} action "$@" chain "${out}_${mychain}" dst "224.0.0.0/8" proto 2 || return 1
  1654.     rule ${in} reverse action "$@" chain "${in}_${mychain}" src "224.0.0.0/8" proto 2 || return 1
  1655.     
  1656.     return 0
  1657. }
  1658.  
  1659.  
  1660. # --- CUSTOM -------------------------------------------------------------------
  1661.  
  1662. rules_custom() {
  1663.     local mychain="${1}"; shift
  1664.     local type="${1}"; shift
  1665.     
  1666.     local server="${1}"; shift
  1667.     local my_server_ports="${1}"; shift
  1668.     local my_client_ports="${1}"; shift
  1669.     
  1670.     local in=in
  1671.     local out=out
  1672.     if [ "${type}" = "client" ]
  1673.     then
  1674.         in=out
  1675.         out=in
  1676.     fi
  1677.     
  1678.     local client_ports="${DEFAULT_CLIENT_PORTS}"
  1679.     if [ "${type}" = "client" -a "${work_cmd}" = "interface" ]
  1680.     then
  1681.         client_ports="${LOCAL_CLIENT_PORTS}"
  1682.     fi
  1683.     
  1684.     # ----------------------------------------------------------------------
  1685.     
  1686.     local sp=
  1687.     for sp in ${my_server_ports}
  1688.     do
  1689.         local proto=
  1690.         local sport=
  1691.         
  1692.         IFS="/" read proto sport <<EOF
  1693. $sp
  1694. EOF
  1695.         
  1696.         local cp=
  1697.         for cp in ${my_client_ports}
  1698.         do
  1699.             local cport=
  1700.             case ${cp} in
  1701.                 default)
  1702.                     cport="${client_ports}"
  1703.                     ;;
  1704.                     
  1705.                 *)    cport="${cp}"
  1706.                     ;;
  1707.             esac
  1708.             
  1709.             # allow new and established incoming packets
  1710.             rule ${in} action "$@" chain "${in}_${mychain}" proto "${proto}" sport "${cport}" dport "${sport}" state NEW,ESTABLISHED || return 1
  1711.             
  1712.             # allow outgoing established packets
  1713.             rule ${out} reverse action "$@" chain "${out}_${mychain}" proto "${proto}" sport "${cport}" dport "${sport}" state ESTABLISHED || return 1
  1714.         done
  1715.     done
  1716.     
  1717.     return 0
  1718. }
  1719.  
  1720.  
  1721. # ------------------------------------------------------------------------------
  1722.  
  1723. # The caller may need just our services definitions
  1724. if [ "$1" = "gimme-the-services-defs" ]
  1725. then
  1726.     return 0
  1727.     exit 1
  1728. fi
  1729.  
  1730.  
  1731. # ------------------------------------------------------------------------------
  1732. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1733. # ------------------------------------------------------------------------------
  1734. #
  1735. # SUPPORT FOR EXTERNAL DEFINITIONS OF SERVICES
  1736. #
  1737. # ------------------------------------------------------------------------------
  1738. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1739. # ------------------------------------------------------------------------------
  1740.  
  1741. # Load all the services.
  1742. # All these files should start with: #FHVER: 1
  1743. cd "${FIREHOL_CONFIG_DIR}/services" || exit 1
  1744. for f in `ls *.conf 2>/dev/null`
  1745. do
  1746.     cd "${FIREHOL_CONFIG_DIR}/services" || exit 1
  1747.     
  1748.     if [ ! -O "${f}" ]
  1749.     then
  1750.         echo >&2 " >>> Ignoring service in '${FIREHOL_CONFIG_DIR}/services/${f}' because it is not owned by root."
  1751.         continue
  1752.     fi
  1753.     
  1754.     n=`"${HEAD_CMD}" -n 1 "${f}" | "${CUT_CMD}" -d ':' -f 2`
  1755.     "${EXPR_CMD}" ${n} + 0 >/dev/null 2>&1
  1756.     if [ $? -ne 0 ]
  1757.     then
  1758.         echo >&2 " >>> Ignoring service in '${FIREHOL_CONFIG_DIR}/services/${f}' due to malformed header."
  1759.     elif [ ${n} -ne ${FIREHOL_SERVICES_API} ]
  1760.     then
  1761.         echo >&2 " >>> Ignoring service '${FIREHOL_CONFIG_DIR}/services/${f}' due to incompatible API version."
  1762.     else
  1763.         n=`"${HEAD_CMD}" -n 1 "${f}" | "${CUT_CMD}" -d ':' -f 3`
  1764.         "${EXPR_CMD}" ${n} + 0 >/dev/null 2>&1
  1765.         if [ $? -ne 0 ]
  1766.         then
  1767.             echo >&2 " >>> Ignoring service in '${FIREHOL_CONFIG_DIR}/services/${f}' due to malformed API minor number."
  1768.         else
  1769.             if [ ${n} -gt ${FIREHOL_MINOR_VERSION} ]
  1770.             then
  1771.                 echo >&2 " >>> Ignoring service in '${FIREHOL_CONFIG_DIR}/services/${f}' because the required MINOR version (${n}) is higher than the one provided by FireHOL (${FIREHOL_MINOR_VERSION})."
  1772.             else
  1773.                 source ${f}
  1774.                 ret=$?
  1775.                 if [ ${ret} -ne 0 ]
  1776.                 then
  1777.                     echo >&2 " >>> Service in '${FIREHOL_CONFIG_DIR}/services/${f}' returned code ${ret}."
  1778.                     continue
  1779.                 fi
  1780.             fi
  1781.         fi
  1782.     fi
  1783. done
  1784. cd "${FIREHOL_DEFAULT_WORKING_DIRECTORY}" || exit 1
  1785.  
  1786.  
  1787. # ------------------------------------------------------------------------------
  1788. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1789. # ------------------------------------------------------------------------------
  1790. #
  1791. # HELPER FUNCTIONS BELLOW THIS POINT
  1792. #
  1793. # ------------------------------------------------------------------------------
  1794. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1795. # ------------------------------------------------------------------------------
  1796.  
  1797. # Fetch a URL and output it to the standard output.
  1798. firehol_wget() {
  1799.     local url="${1}"
  1800.     
  1801.     require_cmd wget curl || error "Cannot find 'wget' or 'curl' in the path."
  1802.     
  1803.     if [ ! -z "${WGET_CMD}" ]
  1804.     then
  1805.         ${WGET_CMD} -O - "${url}" 2>/dev/null
  1806.         return $?
  1807.     elif [ ! -z "${CURL_CMD}" ]
  1808.     then
  1809.         ${CURL_CMD} -s "${url}"
  1810.         return $?
  1811.     fi
  1812.     
  1813.     error "Cannot use either 'wget' or 'curl' to fetch '${url}'."
  1814.     return 1
  1815. }
  1816.  
  1817. FIREHOL_ECN_SHAME_URL="http://urchin.earth.li/cgi-bin/ecn.pl?output=ip"
  1818. ecn_shame() {
  1819.     work_realcmd_helper ${FUNCNAME} "$@"
  1820.     
  1821.     set_work_function -ne "Initializing $FUNCNAME"
  1822.     
  1823.     require_work clear || ( error "$FUNCNAME cannot be used in '${work_cmd}'. Put it before any '${work_cmd}' definition."; return 1 )
  1824.     
  1825.     if [ `${CAT_CMD} /proc/sys/net/ipv4/tcp_ecn` -eq 1 ]
  1826.     then
  1827.         set_work_function "Fetching '${FIREHOL_ECN_SHAME_URL}'."
  1828.         
  1829.         # Reads in list of ip address and makes iptables rules to drop ecn
  1830.         # from packets destined for those hosts.
  1831.         # http://urchin.earth.li/ecn/
  1832.         
  1833.         local tmp="${FIREHOL_DIR}/ecn_shame.ips"
  1834.         
  1835.         firehol_wget "${FIREHOL_ECN_SHAME_URL}" | ${SORT_CMD} | ${UNIQ_CMD} >"${tmp}"
  1836.         if [ $? -ne 0 -o ! -s "${tmp}" ]
  1837.         then
  1838.             softwarning "Cannot fetch '${FIREHOL_ECN_SHAME_URL}'."
  1839.         else
  1840.             ${MV_CMD} -f "${tmp}" "${FIREHOL_SPOOL_DIR}/ecn_shame.ips"
  1841.         fi
  1842.         
  1843.         set_work_function "Removing ECN for all communication from/to SHAME ECN list."
  1844.         
  1845.         local count=0
  1846.         for ip in `${CAT_CMD} "${FIREHOL_SPOOL_DIR}/ecn_shame.ips"`
  1847.         do
  1848.             local count=$[count + 1]
  1849.             iptables -t mangle -A POSTROUTING -p tcp -d ${ip} -j ECN --ecn-tcp-remove
  1850.         done
  1851.         
  1852.         test ${count} -eq 0 && softwarning "No ECN SHAME IPs found." && return 1
  1853.     else
  1854.         softwarning "TCP_ECN is not enabled in the kernel. ECN_SHAME helper is ignored."
  1855.         return 0
  1856.     fi
  1857.     return 0
  1858. }
  1859.  
  1860. masquerade() {
  1861.     work_realcmd_helper ${FUNCNAME} "$@"
  1862.     
  1863.     set_work_function -ne "Initializing $FUNCNAME"
  1864.     
  1865.     local f="${work_outface}"
  1866.     test "${1}" = "reverse" && f="${work_inface}" && shift
  1867.     
  1868.     test -z "${f}" && local f="${1}" && shift
  1869.     
  1870.     test -z "${f}" && error "masquerade requires an interface set or as argument" && return 1
  1871.     
  1872.     set_work_function "Initializing masquerade on interface '${f}'"
  1873.     
  1874.     rule noowner table nat chain POSTROUTING "$@" inface any outface "${f}" action MASQUERADE || return 1
  1875.     
  1876.     FIREHOL_NAT=1
  1877.     FIREHOL_ROUTING=1
  1878.     
  1879.     return 0
  1880. }
  1881.  
  1882. transparent_proxy_count=0
  1883. transparent_proxy() {
  1884.     work_realcmd_helper $FUNCNAME "$@"
  1885.     
  1886.     set_work_function -ne "Initializing $FUNCNAME"
  1887.     
  1888.     require_work clear || ( error "$FUNCNAME cannot be used in '${work_cmd}'. Put it before any '${work_cmd}' definition."; return 1 )
  1889.     
  1890.     local ports="${1}"; shift
  1891.     local redirect="${1}"; shift
  1892.     local user="${1}"; shift
  1893.     
  1894.     test -z "${redirect}" && error "Proxy listening port is empty" && return 1
  1895.     
  1896.     transparent_proxy_count=$[transparent_proxy_count + 1]
  1897.     
  1898.     set_work_function "Setting up rules for catching routed tcp/${ports} traffic"
  1899.     
  1900.     create_chain nat "in_trproxy.${transparent_proxy_count}" PREROUTING noowner "$@" outface any proto tcp sport "${DEFAULT_CLIENT_PORTS}" dport "${ports}" || return 1
  1901. #    rule table nat chain "in_trproxy.${transparent_proxy_count}" proto tcp dport "${ports}" action REDIRECT to-port ${redirect} || return 1
  1902.     rule table nat chain "in_trproxy.${transparent_proxy_count}" proto tcp action REDIRECT to-port ${redirect} || return 1
  1903.     
  1904.     if [ ! -z "${user}" ]
  1905.     then
  1906.         set_work_function "Setting up rules for catching outgoing tcp/${ports} traffic"
  1907.         create_chain nat "out_trproxy.${transparent_proxy_count}" OUTPUT "$@" uid not "${user}" nosoftwarnings inface any outface any src any proto tcp sport "${LOCAL_CLIENT_PORTS}" dport "${ports}" || return 1
  1908.         
  1909.         # do not catch traffic for localhost servers
  1910.         rule table nat chain "out_trproxy.${transparent_proxy_count}" dst "127.0.0.1" action RETURN || return 1
  1911.         
  1912. #        rule table nat chain "out_trproxy.${transparent_proxy_count}" proto tcp dport "${ports}" action REDIRECT to-port ${redirect} || return 1
  1913.         rule table nat chain "out_trproxy.${transparent_proxy_count}" proto tcp action REDIRECT to-port ${redirect} || return 1
  1914.     fi
  1915.     
  1916.     FIREHOL_NAT=1
  1917.     FIREHOL_ROUTING=1
  1918.     
  1919.     return 0
  1920. }
  1921.  
  1922. transparent_squid() {
  1923.     transparent_proxy 80 "$@"
  1924. }
  1925.  
  1926. nat_count=0
  1927. nat_helper() {
  1928. #    work_realcmd_helper $FUNCNAME "$@"
  1929.     
  1930.     set_work_function -ne "Initializing $FUNCNAME"
  1931.     
  1932.     require_work clear || ( error "NAT cannot be used in '${work_cmd}'. Put all NAT related commands before any '${work_cmd}' definition."; return 1 )
  1933.     
  1934.     local type="${1}"; shift
  1935.     local to="${1}";   shift
  1936.     
  1937.     nat_count=$[nat_count + 1]
  1938.     
  1939.     set_work_function -ne "Setting up rules for NAT type: '${type}'"
  1940.     
  1941.     case ${type} in
  1942.         to-source)
  1943.             create_chain nat "nat.${nat_count}" POSTROUTING nolog "$@" inface any || return 1
  1944.             local action=snat
  1945.             ;;
  1946.         
  1947.         to-destination)
  1948.             create_chain nat "nat.${nat_count}" PREROUTING noowner nolog "$@" outface any || return 1
  1949.             local action=dnat
  1950.             ;;
  1951.             
  1952.         redirect-to)
  1953.             create_chain nat "nat.${nat_count}" PREROUTING noowner nolog "$@" outface any || return 1
  1954.             local action=redirect
  1955.             ;;
  1956.             
  1957.         *)
  1958.             error "$FUNCNAME requires a type (i.e. to-source, to-destination, redirect-to, etc) as its first argument. '${type}' is not understood."
  1959.             return 1
  1960.             ;;
  1961.     esac
  1962.     
  1963.     
  1964.     set_work_function "Taking the NAT action: '${action}'"
  1965.     
  1966.     # we now need to keep the protocol
  1967.     rule table nat chain "nat.${nat_count}" noowner "$@" action "${action}" to "${to}" nosoftwarnings src any dst any inface any outface any sport any dport any || return 1
  1968.     
  1969.     FIREHOL_NAT=1
  1970.     FIREHOL_ROUTING=1
  1971.     
  1972.     return 0
  1973. }
  1974.  
  1975. nat() {
  1976.     work_realcmd_helper $FUNCNAME "$@"
  1977.     
  1978.     set_work_function -ne "Initializing $FUNCNAME"
  1979.     
  1980.     nat_helper "$@"
  1981. }
  1982.  
  1983. snat() {
  1984.     work_realcmd_helper $FUNCNAME "$@"
  1985.     
  1986.     set_work_function -ne "Initializing $FUNCNAME"
  1987.     
  1988.     local to="${1}"; shift
  1989.     test "${to}" = "to" && local to="${1}" && shift
  1990.     
  1991.     nat_helper "to-source" "${to}" "$@"
  1992. }
  1993.  
  1994. dnat() {
  1995.     work_realcmd_helper $FUNCNAME "$@"
  1996.     
  1997.     set_work_function -ne "Initializing $FUNCNAME"
  1998.     
  1999.     local to="${1}"; shift
  2000.     test "${to}" = "to" && local to="${1}" && shift
  2001.     
  2002.     nat_helper "to-destination" "${to}" "$@"
  2003. }
  2004.  
  2005. redirect() {
  2006.     work_realcmd_helper $FUNCNAME "$@"
  2007.     
  2008.     set_work_function -ne "Initializing $FUNCNAME"
  2009.     
  2010.     local to="${1}"; shift
  2011.     test "${to}" = "to" -o "${to}" = "to-port" && local to="${1}" && shift
  2012.     
  2013.     nat_helper "redirect-to" "${to}" "$@"
  2014. }
  2015.  
  2016. wrongmac_chain=0
  2017. mac() {
  2018.     work_realcmd_helper $FUNCNAME "$@"
  2019.     
  2020.     set_work_function -ne "Initializing $FUNCNAME"
  2021.     
  2022.     require_work clear || ( error "$FUNCNAME cannot be used in '${work_cmd}'. Put it before any '${work_cmd}' definition."; return 1 )
  2023.     
  2024.     if [ ${wrongmac_chain} -eq 0 ]
  2025.     then
  2026.         set_work_function "Creating the MAC-MISSMATCH chain (only once)"
  2027.         
  2028.         iptables -t filter -N WRONGMAC
  2029.         rule table filter chain WRONGMAC loglimit "MAC MISSMATCH" action DROP || return 1
  2030.         
  2031.         wrongmac_chain=1
  2032.     fi
  2033.     
  2034.     set_work_function "If the source IP ${1} does not match MAC ${2}, drop the packet"
  2035.     
  2036.     iptables -t filter -A INPUT   -s "${1}" -m mac --mac-source ! "${2}" -j WRONGMAC
  2037.     iptables -t filter -A FORWARD -s "${1}" -m mac --mac-source ! "${2}" -j WRONGMAC
  2038.     
  2039.     return 0
  2040. }
  2041.  
  2042. # blacklist creates two types of blacklists: unidirectional or bidirectional
  2043. blacklist_chain=0
  2044. blacklist() {
  2045.     work_realcmd_helper ${FUNCNAME} "$@"
  2046.     
  2047.     set_work_function -ne "Initializing $FUNCNAME"
  2048.     
  2049.     require_work clear || ( error "$FUNCNAME cannot be used in '${work_cmd}'. Put it before any '${work_cmd}' definition."; return 1 )
  2050.     
  2051.     local full=1
  2052.     if [ "${1}" = "them" -o "${1}" = "him" -o "${1}" = "her" -o "${1}" = "it" -o "${1}" = "this" -o "${1}" = "these"  -o "${1}" = "input" ]
  2053.     then
  2054.         shift
  2055.         full=0
  2056.     elif [ "${1}" = "all" -o "${1}" = "full" ]
  2057.     then
  2058.         shift
  2059.         full=1
  2060.     fi
  2061.     
  2062.     if [ ${blacklist_chain} -eq 0 ]
  2063.     then
  2064.         set_work_function "Generating blacklist chains"
  2065.         
  2066.         # Blacklist INPUT unidirectional
  2067.         iptables -t filter -N BL_IN_UNI    # INPUT
  2068.         iptables -A BL_IN_UNI -m state --state NEW -j DROP
  2069.         
  2070.         # No need for OUTPUT/FORWARD unidirectional
  2071.         
  2072.         # Blacklist INPUT bidirectional
  2073.         iptables -t filter -N BL_IN_BI    # INPUT
  2074.         iptables -A BL_IN_BI -j DROP
  2075.         
  2076.         # Blacklist OUTPUT/FORWARD bidirectional
  2077.         iptables -t filter -N BL_OUT_BI    # OUTPUT and FORWARD
  2078.         iptables -A BL_OUT_BI -p tcp -j REJECT --reject-with tcp-reset
  2079.         iptables -A BL_OUT_BI -j REJECT --reject-with icmp-host-unreachable
  2080.         
  2081.         blacklist_chain=1
  2082.     fi
  2083.     
  2084.     set_work_function "Generating blacklist rules"
  2085.     
  2086.     local z=
  2087.     for z in $@
  2088.     do
  2089.         local x=
  2090.         for x in ${z}
  2091.         do
  2092.             set_work_function "Blacklisting '${x}'"
  2093.             
  2094.             if [ ${full} -eq 1 ]
  2095.             then
  2096.                 iptables -I INPUT   -s ${x} -j BL_IN_BI
  2097.                 iptables -I FORWARD -s ${x} -j BL_IN_BI
  2098.                 
  2099.                 iptables -I OUTPUT  -d ${x} -j BL_OUT_BI
  2100.                 iptables -I FORWARD -d ${x} -j BL_OUT_BI  
  2101.             else
  2102.                 iptables -I INPUT   -s ${x} -j BL_IN_UNI
  2103.                 iptables -I FORWARD -s ${x} -j BL_IN_UNI
  2104.             fi
  2105.         done
  2106.     done
  2107.     
  2108.     return 0
  2109. }
  2110.  
  2111. mark_count=0
  2112. mark() {
  2113.     work_realcmd_helper $FUNCNAME "$@"
  2114.     
  2115.     set_work_function -ne "Initializing $FUNCNAME"
  2116.     
  2117.     require_work clear || ( error "$FUNCNAME cannot be used in '${work_cmd}'. Put it before any '${work_cmd}' definition."; return 1 )
  2118.     
  2119.     local num="${1}"; shift
  2120.     local where="${1}"; shift
  2121.     test -z "${where}" && where=OUTPUT
  2122.     
  2123.     mark_count=$[mark_count + 1]
  2124.     
  2125.     set_work_function "Setting up rules for MARK"
  2126.     
  2127.     create_chain mangle "mark.${mark_count}" "${where}" "$@" || return 1
  2128.     iptables -t mangle -A "mark.${mark_count}" -j MARK --set-mark ${num}
  2129.     
  2130.     return 0
  2131. }
  2132.  
  2133. tos_count=0
  2134. tos() {
  2135.     work_realcmd_helper $FUNCNAME "$@"
  2136.     
  2137.     set_work_function -ne "Initializing $FUNCNAME"
  2138.     
  2139.     require_work clear || ( error "$FUNCNAME cannot be used in '${work_cmd}'. Put it before any '${work_cmd}' definition."; return 1 )
  2140.     
  2141.     local num="${1}"; shift
  2142.     local where="${1}"; shift
  2143.     test -z "${where}" && where=OUTPUT
  2144.     
  2145.     tos_count=$[tos_count + 1]
  2146.     
  2147.     set_work_function "Setting up rules for TOS"
  2148.     
  2149.     create_chain mangle "tos.${tos_count}" "${where}" "$@" || return 1
  2150.     iptables -t mangle -A "tos.${tos_count}" -j TOS --set-tos ${num}
  2151.     
  2152.     return 0
  2153. }
  2154.  
  2155. dscp_count=0
  2156. dscp() {
  2157.     work_realcmd=($FUNCNAME "$@")
  2158.     
  2159.     set_work_function -ne "Initializing $FUNCNAME"
  2160.     
  2161.     require_work clear || ( error "$FUNCNAME cannot be used in '${work_cmd}'. Put it before any '${work_cmd}' definition."; return 1 )
  2162.     
  2163.     local value="${1}"; shift
  2164.     local class=""
  2165.     
  2166.     if [ "${value}" = "class" ]
  2167.     then
  2168.         local value=""
  2169.         local class="${1}"; shift
  2170.     fi
  2171.     
  2172.     local where="${1}"; shift
  2173.     test -z "${where}" && where=OUTPUT
  2174.     
  2175.     dscp_count=$[dscp_count + 1]
  2176.     
  2177.     set_work_function "Setting up rules for setting DSCP"
  2178.     
  2179.     create_chain mangle "dscp.${dscp_count}" "${where}" "$@" || return 1
  2180.     
  2181.     if [ ! -z "${class}" ]
  2182.     then
  2183.         iptables -t mangle -A "dscp.${dscp_count}" -j DSCP --set-dscp-class ${class}
  2184.     else
  2185.         iptables -t mangle -A "dscp.${dscp_count}" -j DSCP --set-dscp ${value}
  2186.     fi
  2187.     
  2188.     return 0
  2189. }
  2190.  
  2191. tcpmss() {
  2192.     work_realcmd_helper $FUNCNAME "$@"
  2193.     
  2194.     set_work_function -ne "Initializing $FUNCNAME"
  2195.     
  2196.     # work only if this helper is called before any primary command
  2197.     # or within routers.
  2198.     if [ -z "${work_cmd}" -o "${work_cmd}" = "router" ]
  2199.     then
  2200.         local chains="FORWARD"
  2201.         
  2202.         test ! -z "${work_cmd}" && chains="in_${work_name} out_${work_name}"
  2203.         
  2204.         for tcmpmss_chain in ${chains}
  2205.         do
  2206.             case $1 in
  2207.                 auto)
  2208.                     iptables -A "${tcmpmss_chain}" -p tcp --tcp-flags SYN,RST SYN -j TCPMSS --clamp-mss-to-pmtu
  2209.                     ;;
  2210.                     
  2211.                 [0-9]*)
  2212.                     iptables -A "${tcmpmss_chain}" -p tcp --tcp-flags SYN,RST SYN -j TCPMSS --set-mss $1
  2213.                     ;;
  2214.                 
  2215.                 *)
  2216.                     error "$FUNCNAME requires either the word 'auto' or a numeric argument."
  2217.                     return 1
  2218.                     ;;
  2219.             esac
  2220.         done
  2221.     else
  2222.         error "$FUNCNAME cannot be used in '${work_cmd}'. Put it before any '${work_cmd}' definition or in 'router' definitions."
  2223.         return 1
  2224.     fi
  2225.     
  2226.     return 0
  2227. }
  2228.  
  2229.  
  2230. # ------------------------------------------------------------------------------
  2231. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  2232. # ------------------------------------------------------------------------------
  2233. #
  2234. # INTERNAL FUNCTIONS BELLOW THIS POINT - Primary commands
  2235. #
  2236. # ------------------------------------------------------------------------------
  2237. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  2238. # ------------------------------------------------------------------------------
  2239.  
  2240.  
  2241. # ------------------------------------------------------------------------------
  2242. # Check the version required by the configuration file
  2243. # WHY:
  2244. # We have to make sure the configuration file has been written for this version
  2245. # of FireHOL. Note that the version command does not actually check the version
  2246. # of firehol.sh. It checks only its release number (R5 currently).
  2247.  
  2248. version() {
  2249.         work_realcmd_helper ${FUNCNAME} "$@"
  2250.     
  2251.     if [ ${1} -gt ${FIREHOL_VERSION} ]
  2252.     then
  2253.         error "Wrong version. FireHOL is v${FIREHOL_VERSION}, your script requires v${1}."
  2254.     fi
  2255. }
  2256.  
  2257.  
  2258. # ------------------------------------------------------------------------------
  2259. # PRIMARY COMMAND: interface
  2260. # Setup rules specific to an interface (physical or logical)
  2261.  
  2262. interface() {
  2263.         work_realcmd_primary ${FUNCNAME} "$@"
  2264.     
  2265.     # --- close any open command ---
  2266.     
  2267.     close_cmd || return 1
  2268.     
  2269.     
  2270.     # --- test prerequisites ---
  2271.     
  2272.     require_work clear || return 1
  2273.     set_work_function -ne "Initializing $FUNCNAME"
  2274.     
  2275.     
  2276.     # --- get paramaters and validate them ---
  2277.     
  2278.     # Get the interface
  2279.     local inface="${1}"; shift
  2280.     test -z "${inface}" && error "real interface is not set" && return 1
  2281.     
  2282.     # Get the name for this interface
  2283.     local name="${1}"; shift
  2284.     test -z "${name}" && error "$FUNCNAME name is not set" && return 1
  2285.     
  2286.     
  2287.     # --- do the job ---
  2288.     
  2289.     work_cmd="${FUNCNAME}"
  2290.     work_name="${name}"
  2291.     work_realcmd=("(unset)")
  2292.     
  2293.     set_work_function -ne "Initializing $FUNCNAME '${work_name}'"
  2294.     
  2295.     create_chain filter "in_${work_name}" INPUT in set_work_inface "$@" inface "${inface}" outface any || return 1
  2296.     create_chain filter "out_${work_name}" OUTPUT out set_work_outface reverse "$@" inface "${inface}" outface any || return 1
  2297.     
  2298.     return 0
  2299. }
  2300.  
  2301.  
  2302. router() {
  2303.         work_realcmd_helper ${FUNCNAME} "$@"
  2304.     
  2305.     # --- close any open command ---
  2306.     
  2307.     close_cmd || return 1
  2308.     
  2309.     
  2310.     # --- test prerequisites ---
  2311.     
  2312.     require_work clear || return 1
  2313.     set_work_function -ne "Initializing $FUNCNAME"
  2314.     
  2315.     
  2316.     # --- get paramaters and validate them ---
  2317.     
  2318.     # Get the name for this router
  2319.     local name="${1}"; shift
  2320.     test -z "${name}" && error "$FUNCNAME name is not set" && return 1
  2321.     
  2322.     
  2323.     # --- do the job ---
  2324.     
  2325.     work_cmd="${FUNCNAME}"
  2326.     work_name="${name}"
  2327.     work_realcmd=("(unset)")
  2328.     
  2329.     set_work_function -ne "Initializing $FUNCNAME '${work_name}'"
  2330.     
  2331.     create_chain filter "in_${work_name}" FORWARD in set_work_inface set_work_outface "$@" || return 1
  2332.     create_chain filter "out_${work_name}" FORWARD out reverse "$@" || return 1
  2333.     
  2334.     FIREHOL_ROUTING=1
  2335.     
  2336.     return 0
  2337. }
  2338.  
  2339. postprocess() {
  2340. #       work_realcmd_helper ${FUNCNAME} "$@"
  2341.     
  2342.     local check="error"
  2343.     test "A${1}" = "A-ne"   && shift && local check="none"
  2344.     test "A${1}" = "A-warn" && shift && local check="warn"
  2345.     
  2346.     test ${FIREHOL_DEBUG}   -eq 1 && local check="none"
  2347.     test ${FIREHOL_EXPLAIN} -eq 1 && local check="none"
  2348.     
  2349.     if [ ! ${check} = "none" ]
  2350.     then
  2351.         printf "runcmd '${check}' '${FIREHOL_LINEID}' " >>${FIREHOL_OUTPUT}
  2352.     fi
  2353.     
  2354.     printf "%q " "$@" >>${FIREHOL_OUTPUT}
  2355.     printf "\n" >>${FIREHOL_OUTPUT}
  2356.     
  2357.     if [ ${FIREHOL_EXPLAIN} -eq 1 ]
  2358.     then
  2359.         ${CAT_CMD} ${FIREHOL_OUTPUT}
  2360.         ${RM_CMD} -f ${FIREHOL_OUTPUT}
  2361.     fi
  2362.     
  2363.     return 0
  2364. }
  2365.  
  2366. runcmd() {
  2367.     local check="${1}"; shift
  2368.     local line="${1}"; shift
  2369.     local cmd="${1}"; shift
  2370.     
  2371.     "${cmd}" "$@" >${FIREHOL_OUTPUT}.log 2>&1
  2372.     local r=$?
  2373.     test ${r} -gt 0 && runtime_error ${check} ${r} ${line} "${cmd}" "$@"
  2374.     
  2375.     return 0
  2376. }
  2377.  
  2378. FIREHOL_COMMAND_COUNTER=0
  2379. iptables() {
  2380. #       work_realcmd_helper ${FUNCNAME} "$@"
  2381.     
  2382.     postprocess "${IPTABLES_CMD}" "$@"
  2383.     FIREHOL_COMMAND_COUNTER=$[FIREHOL_COMMAND_COUNTER + 1]
  2384.     
  2385.     return 0
  2386. }
  2387.  
  2388.  
  2389. # ------------------------------------------------------------------------------
  2390. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  2391. # ------------------------------------------------------------------------------
  2392. #
  2393. # INTERNAL FUNCTIONS BELLOW THIS POINT - Sub-commands
  2394. #
  2395. # ------------------------------------------------------------------------------
  2396. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  2397. # ------------------------------------------------------------------------------
  2398.  
  2399.  
  2400. # ------------------------------------------------------------------------------
  2401. # Change the policy of an interface
  2402. # WHY:
  2403. # Not all interfaces have the same policy. The admin must have control over it.
  2404. # Here we just set what the admin wants. At the interface finalization we
  2405. # produce the iptables rules.
  2406.  
  2407. policy() {
  2408.         work_realcmd_secondary ${FUNCNAME} "$@"
  2409.     
  2410.     require_work set interface || return 1
  2411.     
  2412.     set_work_function "Setting interface '${work_inface}' (${work_name}) policy to ${1}"
  2413.     work_policy="$*"
  2414.     
  2415.     return 0
  2416. }
  2417.  
  2418. server() {
  2419.     work_realcmd_secondary ${FUNCNAME} "$@"
  2420.     
  2421.     require_work set any || return 1
  2422.     smart_function server "$@"
  2423.     return $?
  2424. }
  2425.  
  2426. client() {
  2427.         work_realcmd_secondary ${FUNCNAME} "$@"
  2428.     
  2429.     require_work set any || return 1
  2430.     smart_function client "$@"
  2431.     return $?
  2432. }
  2433.  
  2434. route() {
  2435.         work_realcmd_secondary ${FUNCNAME} "$@"
  2436.     
  2437.     require_work set router || return 1
  2438.     smart_function server "$@"
  2439.     return $?
  2440. }
  2441.  
  2442.  
  2443. # --- protection ---------------------------------------------------------------
  2444.  
  2445. protection() {
  2446.         work_realcmd_secondary ${FUNCNAME} "$@"
  2447.     
  2448.     require_work set any || return 1
  2449.     
  2450.     local in="in"
  2451.     local prface="${work_inface}"
  2452.     
  2453.     local pre="pr"
  2454.     local reverse=
  2455.     if [ "${1}" = "reverse" ]
  2456.     then
  2457.         local reverse="reverse"    # needed to recursion
  2458.         local pre="prr"        # in case a router has protections
  2459.                     # both ways, the second needs to
  2460.                     # have different chain names
  2461.                     
  2462.         local in="out"        # reverse the interface
  2463.         
  2464.         prface="${work_outface}"
  2465.         shift
  2466.     fi
  2467.     
  2468.     local type="${1}"
  2469.     local rate="${2}"
  2470.     local burst="${3}"
  2471.     
  2472.     test -z "${rate}"  && rate="100/s"
  2473.     test -z "${burst}" && burst="50"
  2474.     
  2475.     set_work_function -ne "Generating protections on '${prface}' for ${work_cmd} '${work_name}'"
  2476.     
  2477.     local x=
  2478.     for x in ${type}
  2479.     do
  2480.         case "${x}" in
  2481.             none|NONE)
  2482.                 return 0
  2483.                 ;;
  2484.             
  2485.             strong|STRONG|full|FULL|all|ALL)
  2486.                 protection ${reverse} "invalid fragments new-tcp-w/o-syn icmp-floods syn-floods malformed-xmas malformed-null malformed-bad" "${rate}" "${burst}"
  2487.                 return $?
  2488.                 ;;
  2489.                 
  2490.             invalid|INVALID)
  2491.                 iptables -A "${in}_${work_name}" -m state --state INVALID -j DROP                || return 1
  2492.                 ;;
  2493.                 
  2494.             fragments|FRAGMENTS)
  2495.                 local mychain="${pre}_${work_name}_fragments"
  2496.                 create_chain filter "${mychain}" "${in}_${work_name}" in custom "-f"                || return 1
  2497.                 
  2498.                 set_work_function "Generating rules to be protected from packet fragments on '${prface}' for ${work_cmd} '${work_name}'"
  2499.                 
  2500.                 rule in chain "${mychain}" loglimit "PACKET FRAGMENTS" action drop                 || return 1
  2501.                 ;;
  2502.                 
  2503.             new-tcp-w/o-syn|NEW-TCP-W/O-SYN)
  2504.                 local mychain="${pre}_${work_name}_nosyn"
  2505.                 create_chain filter "${mychain}" "${in}_${work_name}" in proto tcp state NEW custom "! --syn"    || return 1
  2506.                 
  2507.                 set_work_function "Generating rules to be protected from new TCP connections without the SYN flag set on '${prface}' for ${work_cmd} '${work_name}'"
  2508.                 
  2509.                 rule in chain "${mychain}" loglimit "NEW TCP w/o SYN" action drop                || return 1
  2510.                 ;;
  2511.                 
  2512.             icmp-floods|ICMP-FLOODS)
  2513.                 local mychain="${pre}_${work_name}_icmpflood"
  2514.                 create_chain filter "${mychain}" "${in}_${work_name}" in proto icmp custom "--icmp-type echo-request"    || return 1
  2515.                 
  2516.                 set_work_function "Generating rules to be protected from ICMP floods on '${prface}' for ${work_cmd} '${work_name}'"
  2517.                 
  2518.                 rule in chain "${mychain}" limit "${rate}" "${burst}" action return                || return 1
  2519.                 rule in chain "${mychain}" loglimit "ICMP FLOOD" action drop                    || return 1
  2520.                 ;;
  2521.                 
  2522.             syn-floods|SYN-FLOODS)
  2523.                 local mychain="${pre}_${work_name}_synflood"
  2524.                 create_chain filter "${mychain}" "${in}_${work_name}" in proto tcp custom "--syn"        || return 1
  2525.                 
  2526.                 set_work_function "Generating rules to be protected from TCP SYN floods on '${prface}' for ${work_cmd} '${work_name}'"
  2527.                 
  2528.                 rule in chain "${mychain}" limit "${rate}" "${burst}" action return                || return 1
  2529.                 rule in chain "${mychain}" loglimit "SYN FLOOD" action drop                    || return 1
  2530.                 ;;
  2531.                 
  2532.             malformed-xmas|MALFORMED-XMAS)
  2533.                 local mychain="${pre}_${work_name}_malxmas"
  2534.                 create_chain filter "${mychain}" "${in}_${work_name}" in proto tcp custom "--tcp-flags ALL ALL"    || return 1
  2535.                 
  2536.                 set_work_function "Generating rules to be protected from packets with all TCP flags set on '${prface}' for ${work_cmd} '${work_name}'"
  2537.                 
  2538.                 rule in chain "${mychain}" loglimit "MALFORMED XMAS" action drop                || return 1
  2539.                 ;;
  2540.                 
  2541.             malformed-null|MALFORMED-NULL)
  2542.                 local mychain="${pre}_${work_name}_malnull"
  2543.                 create_chain filter "${mychain}" "${in}_${work_name}" in proto tcp custom "--tcp-flags ALL NONE" || return 1
  2544.                 
  2545.                 set_work_function "Generating rules to be protected from packets with all TCP flags unset on '${prface}' for ${work_cmd} '${work_name}'"
  2546.                 
  2547.                 rule in chain "${mychain}" loglimit "MALFORMED NULL" action drop                || return 1
  2548.                 ;;
  2549.                 
  2550.             malformed-bad|MALFORMED-BAD)
  2551.                 local mychain="${pre}_${work_name}_malbad"
  2552.                 create_chain filter "${mychain}" "${in}_${work_name}" in proto tcp custom "--tcp-flags SYN,FIN SYN,FIN"            || return 1
  2553.                 
  2554.                 set_work_function "Generating rules to be protected from packets with illegal TCP flags on '${prface}' for ${work_cmd} '${work_name}'"
  2555.                 
  2556.                 rule in chain "${in}_${work_name}" action "${mychain}"   proto tcp custom "--tcp-flags SYN,RST SYN,RST"            || return 1
  2557.                 rule in chain "${in}_${work_name}" action "${mychain}"   proto tcp custom "--tcp-flags ALL     SYN,RST,ACK,FIN,URG"    || return 1
  2558.                 rule in chain "${in}_${work_name}" action "${mychain}"   proto tcp custom "--tcp-flags ALL     FIN,URG,PSH"        || return 1
  2559.                 
  2560.                 rule in chain "${mychain}" loglimit "MALFORMED BAD" action drop                                || return 1
  2561.                 ;;
  2562.                 
  2563.             *)
  2564.                 error "Protection '${x}' does not exists."
  2565.                 return 1
  2566.                 ;;
  2567.         esac
  2568.     done
  2569.     
  2570.     return 0
  2571. }
  2572.  
  2573.  
  2574. # ------------------------------------------------------------------------------
  2575. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  2576. # ------------------------------------------------------------------------------
  2577. #
  2578. # KERNEL MODULE MANAGEMENT
  2579. #
  2580. # ------------------------------------------------------------------------------
  2581. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  2582. # ------------------------------------------------------------------------------
  2583.  
  2584. # ------------------------------------------------------------------------------
  2585. # Manage kernel modules
  2586. # WHY:
  2587. # We need to load a set of kernel modules during postprocessing, and after the
  2588. # new firewall has been activated. Here we just keep a list of the required
  2589. # kernel modules.
  2590.  
  2591. # optionaly require command gzcat
  2592. require_cmd gzcat
  2593.  
  2594. KERNEL_CONFIG=
  2595. if [ -f "/proc/config" ]
  2596. then
  2597.     KERNEL_CONFIG="/proc/config"
  2598.     ${CAT_CMD} /proc/config >${FIREHOL_DIR}/kcfg
  2599.     source ${FIREHOL_DIR}/kcfg
  2600.     ${RM_CMD} -f ${FIREHOL_DIR}/kcfg    
  2601. elif [ -f "/proc/config.gz" -a ! -z "${GZCAT_CMD}" ]
  2602. then
  2603.     KERNEL_CONFIG="/proc/config.gz"
  2604.     ${GZCAT_CMD} /proc/config.gz >${FIREHOL_DIR}/kcfg
  2605.     source ${FIREHOL_DIR}/kcfg
  2606.     ${RM_CMD} -f ${FIREHOL_DIR}/kcfg
  2607.     
  2608. elif [ -f "/lib/modules/`${UNAME_CMD} -r`/build/.config" ]
  2609. then
  2610.     KERNEL_CONFIG="/lib/modules/`${UNAME_CMD} -r`/build/.config"
  2611.     . "${KERNEL_CONFIG}"
  2612.     
  2613. elif [ -f "/boot/config-`${UNAME_CMD} -r`" ]
  2614. then
  2615.     KERNEL_CONFIG="/boot/config-`${UNAME_CMD} -r`"
  2616.     . "${KERNEL_CONFIG}"
  2617.     
  2618. elif [ -f "/usr/src/linux/.config" ]
  2619. then
  2620.     KERNEL_CONFIG="/usr/src/linux/.config"
  2621.     . "${KERNEL_CONFIG}"
  2622. else
  2623.     echo >&2 " "
  2624.     echo >&2 " IMPORTANT WARNING:"
  2625.     echo >&2 " ------------------"
  2626.     echo >&2 " FireHOL cannot find your current kernel configuration."
  2627.     echo >&2 " Please, either compile your kernel with /proc/config,"
  2628.     echo >&2 " or make sure there is a valid kernel config in:"
  2629.     echo >&2 " /usr/src/linux/.config"
  2630.     echo >&2 " "
  2631.     echo >&2 " Because of this, FireHOL will simply attempt to load"
  2632.     echo >&2 " all kernel modules for the services used, without"
  2633.     echo >&2 " being able to detect failures."
  2634.     echo >&2 " "
  2635. fi
  2636.  
  2637. # activation-phase command to check for the existance of
  2638. # a kernel configuration directive. It returns:
  2639. # 0 = module is already in the kernel
  2640. # 1 = module can be loaded with modprobe
  2641. # 2 = no info about this module in the kernel
  2642. check_kernel_config() {
  2643.     eval local kcfg="\$${1}"
  2644.     
  2645.     case ${kcfg} in
  2646.         y)    return 0
  2647.             ;;
  2648.         
  2649.         m)    return 1
  2650.             ;;
  2651.         
  2652.         *)    return 2
  2653.             ;;
  2654.     esac
  2655.     
  2656.     return 2
  2657. }
  2658.  
  2659. # activation-phase command to check for the existance of
  2660. # a kernel module. It returns:
  2661. # 0 = module is already in the kernel
  2662. # 1 = module can be loaded with modprobe
  2663. # 2 = no info about this module in the kernel
  2664. check_kernel_module() {
  2665.     local mod="${1}"
  2666.     
  2667.     case ${mod} in
  2668.         ip_tables)
  2669.             test -f /proc/net/ip_tables_names && return 0
  2670.             check_kernel_config CONFIG_IP_NF_IPTABLES
  2671.             return $?
  2672.             ;;
  2673.         
  2674.         ip_conntrack)
  2675.             test -f /proc/net/ip_conntrack && return 0
  2676.             check_kernel_config CONFIG_IP_NF_CONNTRACK
  2677.             return $?
  2678.             ;;
  2679.             
  2680.         ip_conntrack_*)
  2681.             local mnam="CONFIG_IP_NF_`echo ${mod} | ${CUT_CMD} -d '_' -f 3- | ${TR_CMD} a-z A-Z`"
  2682.             check_kernel_config ${mnam}
  2683.             return $?
  2684.             ;;
  2685.             
  2686.         ip_nat_*)
  2687.             local mnam="CONFIG_IP_NF_NAT_`echo ${mod} | ${CUT_CMD} -d '_' -f 3- | ${TR_CMD} a-z A-Z`"
  2688.             check_kernel_config ${mnam}
  2689.             return $?
  2690.             ;;
  2691.             
  2692.         *)
  2693.             return 2
  2694.             ;;
  2695.     esac
  2696.     
  2697.     return 2
  2698. }
  2699.  
  2700. # activation-phase command to load a kernel module.
  2701. load_kernel_module() {
  2702.     local mod="${1}"
  2703.     
  2704.     if [ ! ${FIREHOL_LOAD_KERNEL_MODULES} -eq 0 ]
  2705.     then
  2706.         check_kernel_module ${mod}
  2707.         if [ $? -gt 0 ]
  2708.         then
  2709.             runcmd warn ${FIREHOL_LINEID} ${MODPROBE_CMD} ${mod} -q
  2710.         fi
  2711.     fi
  2712.     return 0
  2713. }
  2714.  
  2715. # Processing-phase command to tell FireHOL to find one or more
  2716. # kernel modules to load, during activation-phase.
  2717. require_kernel_module() {
  2718.     local new="${1}"
  2719.     
  2720.     local m=
  2721.     for m in ${FIREHOL_KERNEL_MODULES}
  2722.     do
  2723.         test "${m}" = "${new}" && return 0
  2724.     done
  2725.     
  2726.     FIREHOL_KERNEL_MODULES="${FIREHOL_KERNEL_MODULES} ${new}"
  2727.     
  2728.     return 0
  2729. }
  2730.  
  2731.  
  2732. # ------------------------------------------------------------------------------
  2733. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  2734. # ------------------------------------------------------------------------------
  2735. #
  2736. # INTERNAL FUNCTIONS BELLOW THIS POINT - FireHOL internals
  2737. #
  2738. # ------------------------------------------------------------------------------
  2739. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  2740. # ------------------------------------------------------------------------------
  2741.  
  2742.  
  2743. set_work_function() {
  2744.     local show_explain=1
  2745.     test "$1" = "-ne" && shift && local show_explain=0
  2746.     
  2747.     work_function="$*"
  2748.     
  2749.     if [ ${FIREHOL_EXPLAIN} -eq 1 ]
  2750.     then
  2751.         test ${show_explain} -eq 1 && printf "\n# %s\n" "$*"
  2752.     elif [ ${FIREHOL_CONF_SHOW} -eq 1 ]
  2753.     then
  2754.         test ${show_explain} -eq 1 && printf "\n# INFO>>> %s\n" "$*" >>${FIREHOL_OUTPUT}
  2755.     fi
  2756. }
  2757.  
  2758.  
  2759. # ------------------------------------------------------------------------------
  2760. # Check the status of the current primary command.
  2761. # WHY:
  2762. # Some sanity check for the order of commands in the configuration file.
  2763. # Each function has a "require_work type command" in order to check that it is
  2764. # placed in a valid point. This means that if you place a "route" command in an
  2765. # interface section (and many other combinations) it will fail.
  2766.  
  2767. require_work() {
  2768.     local type="${1}"
  2769.     local cmd="${2}"
  2770.     
  2771.     case "${type}" in
  2772.         clear)
  2773.             test ! -z "${work_cmd}" && error "Previous work was not applied." && return 1
  2774.             ;;
  2775.         
  2776.         set)
  2777.             test -z "${work_cmd}" && error "The command used requires that a primary command is set." && return 1
  2778.             test ! "${work_cmd}" = "${cmd}" -a ! "${cmd}" = "any"  && error "Primary command is '${work_cmd}' but '${cmd}' is required." && return 1
  2779.             ;;
  2780.             
  2781.         *)
  2782.             error "Unknown work status '${type}'."
  2783.             return 1
  2784.             ;;
  2785.     esac
  2786.     
  2787.     return 0
  2788. }
  2789.  
  2790.  
  2791. # ------------------------------------------------------------------------------
  2792. # Finalizes the rules of the last primary command.
  2793. # WHY:
  2794. # At the end of an interface or router we need to add some code to apply its
  2795. # policy, accept all related packets, etc.
  2796. # Finalization occures automatically when a new primary command is executed and
  2797. # when the configuration file finishes.
  2798.  
  2799. close_cmd() {
  2800.     set_work_function -ne "Closing last open primary command (${work_cmd}/${work_name})"
  2801.     
  2802.     case "${work_cmd}" in
  2803.         interface)
  2804.             close_interface || return 1
  2805.             ;;
  2806.         
  2807.         router)
  2808.             close_router || return 1
  2809.             ;;
  2810.         
  2811.         '')
  2812.             ;;
  2813.         
  2814.         *)
  2815.             error "Unknown work '${work_cmd}'."
  2816.             return 1
  2817.             ;;
  2818.     esac
  2819.     
  2820.     # Reset the current status variables to empty/default
  2821.     work_counter=0
  2822.     work_cmd=
  2823.     work_realcmd=("(unset)")
  2824.     work_name=
  2825.     work_inface=
  2826.     work_outface=
  2827.     work_policy="${DEFAULT_INTERFACE_POLICY}"
  2828.     
  2829.     return 0
  2830. }
  2831.  
  2832. # ------------------------------------------------------------------------------
  2833. # close_interface
  2834. # WHY:
  2835. # Finalizes the rules for the last interface().
  2836.  
  2837. close_interface() {
  2838.     require_work set interface || return 1
  2839.     
  2840.     close_all_groups
  2841.     
  2842.     set_work_function "Finilizing interface '${work_name}'"
  2843.     
  2844.     case "${work_policy}" in
  2845.         return|RETURN)
  2846.             return 0
  2847.             ;;
  2848.             
  2849.         accept|ACCEPT)
  2850.             ;;
  2851.         
  2852.         *)
  2853.             local -a inlog=(loglimit "'IN-${work_name}'")
  2854.             local -a outlog=(loglimit "'OUT-${work_name}'")
  2855.             ;;
  2856.     esac
  2857.     
  2858.     # Accept all related traffic to the established connections
  2859.     rule chain "in_${work_name}" state RELATED action ACCEPT || return 1
  2860.     rule chain "out_${work_name}" state RELATED action ACCEPT || return 1
  2861.     
  2862.     rule chain "in_${work_name}" "${inlog[@]}" action ${work_policy} || return 1
  2863.     rule reverse chain "out_${work_name}" "${outlog[@]}" action ${work_policy} || return 1
  2864.     
  2865.     return 0
  2866. }
  2867.  
  2868.  
  2869. # ------------------------------------------------------------------------------
  2870. # close_router
  2871. # WHY:
  2872. # Finalizes the rules for the last router().
  2873.  
  2874. close_router() {    
  2875.     require_work set router || return 1
  2876.     
  2877.     close_all_groups
  2878.     
  2879.     set_work_function "Finilizing router '${work_name}'"
  2880.     
  2881.     # Accept all related traffic to the established connections
  2882.     rule chain "in_${work_name}" state RELATED action ACCEPT || return 1
  2883.     rule chain "out_${work_name}" state RELATED action ACCEPT || return 1
  2884.     
  2885.     return 0
  2886. }
  2887.  
  2888.  
  2889. # ------------------------------------------------------------------------------
  2890. # close_master
  2891. # WHY:
  2892. # Finalizes the rules for the whole firewall.
  2893. # It assummes there is not primary command open.
  2894.  
  2895. close_master() {
  2896.     set_work_function "Finilizing firewall policies"
  2897.     
  2898.     # Accept all related traffic to the established connections
  2899.     rule chain INPUT state RELATED action ACCEPT || return 1
  2900.     rule chain OUTPUT state RELATED action ACCEPT || return 1
  2901.     rule chain FORWARD state RELATED action ACCEPT || return 1
  2902.     
  2903.     rule chain INPUT loglimit "IN-unknown" action ${UNMATCHED_INPUT_POLICY} || return 1
  2904.     rule chain OUTPUT loglimit "OUT-unknown" action ${UNMATCHED_OUTPUT_POLICY} || return 1
  2905.     rule chain FORWARD loglimit "PASS-unknown" action ${UNMATCHED_ROUTER_POLICY} || return 1
  2906.     return 0
  2907. }
  2908.  
  2909.  
  2910. FIREHOL_GROUP_COUNTER=0
  2911. FIREHOL_GROUP_DEPTH=0
  2912. FIREHOL_GROUP_STACK=()
  2913. group() {
  2914.         work_realcmd_primary ${FUNCNAME} "$@"
  2915.     
  2916.     require_work set any || return 1
  2917.     
  2918.     local type="${1}"; shift
  2919.     
  2920.     case $type in
  2921.         with|start|begin)
  2922.             # increase the counter
  2923.             FIREHOL_GROUP_COUNTER=$[FIREHOL_GROUP_COUNTER + 1]
  2924.             
  2925.             set_work_function "Starting new group No ${FIREHOL_GROUP_COUNTER}, under '${work_name}'"
  2926.             
  2927.             # put the current name in the stack
  2928.             FIREHOL_GROUP_STACK[$FIREHOL_GROUP_DEPTH]=${work_name}
  2929.             FIREHOL_GROUP_DEPTH=$[FIREHOL_GROUP_DEPTH + 1]
  2930.             
  2931.             # name for the new chain
  2932.             mychain="group${FIREHOL_GROUP_COUNTER}"
  2933.             
  2934.             # create the new chain
  2935.             create_chain filter "in_${mychain}" "in_${work_name}" in "$@" || return 1
  2936.             create_chain filter "out_${mychain}" "out_${work_name}" out reverse "$@" || return 1
  2937.             
  2938.             # set a new name for new rules
  2939.             work_name=${mychain}
  2940.             ;;
  2941.         
  2942.         end|stop|close)
  2943.             if [ ${FIREHOL_GROUP_DEPTH} -eq 0 ]
  2944.             then
  2945.                 error "There is no group open to close."
  2946.                 return 1
  2947.             fi
  2948.             
  2949.             # pop one name from the stack
  2950.             FIREHOL_GROUP_DEPTH=$[FIREHOL_GROUP_DEPTH - 1]
  2951.             
  2952.             set_work_function "Closing group '${work_name}'. Now working under '${FIREHOL_GROUP_STACK[$FIREHOL_GROUP_DEPTH]}'"
  2953.             
  2954.             work_name=${FIREHOL_GROUP_STACK[$FIREHOL_GROUP_DEPTH]}
  2955.             ;;
  2956.         
  2957.         *)
  2958.             error "Statement 'group' requires the first argument to be one of with, start, begin, end, stop, close."
  2959.             return 1
  2960.             ;;
  2961.     esac
  2962.     
  2963.     return 0
  2964. }
  2965.  
  2966. close_all_groups() {
  2967.     while [ ${FIREHOL_GROUP_DEPTH} -gt 0 ]
  2968.     do
  2969.         group close || return 1
  2970.     done
  2971.     
  2972.     return 0
  2973. }
  2974.  
  2975.  
  2976.  
  2977. # ------------------------------------------------------------------------------
  2978. # rule - the heart of FireHOL - iptables commands generation
  2979. # WHY:
  2980. # This is the function that gives all the magic to FireHOL. Actually it is a
  2981. # wrapper for iptables, producing multiple iptables commands based on its
  2982. # arguments. The rest of FireHOL is simply a "driver" for this function.
  2983.  
  2984.  
  2985. # rule_action_param() is a function - part of rule() - to create the final iptables cmd
  2986. # taking into account the "action_param" parameter of the action.
  2987.  
  2988. # rule_action_param() should only be used within rule() - no other place
  2989.  
  2990. FIREHOL_ACCEPT_CHAIN_COUNT=0
  2991. rule_action_param() {
  2992.     local action="${1}"; shift
  2993.     local protocol="${1}"; shift
  2994.     local statenot="${1}"; shift
  2995.     local state="${1}"; shift
  2996.     local table="${1}"; shift
  2997.     local -a action_param=()
  2998.     
  2999.     # All arguments until the separator are the parameters of the action
  3000.     local count=0
  3001.     while [ ! -z "${1}" -a ! "A${1}" = "A--" ]
  3002.     do
  3003.         action_param[$count]="${1}"
  3004.         shift
  3005.         
  3006.         count=$[count + 1]
  3007.     done
  3008.     
  3009.     # If we don't have a seperator, generate an error
  3010.     local sep="${1}"; shift
  3011.     if [ ! "A${sep}" = "A--" ]
  3012.     then
  3013.         error "Internal Error, in parsing action_param parameters ($FUNCNAME '${action}' '${protocol}' '${statenot}' '${state}' '${table}' '${action_param[@]}' ${sep} '$@')."
  3014.         return 1
  3015.     fi
  3016.     
  3017.     # Do the rule
  3018.     case "${action}" in
  3019.         NONE)
  3020.             return 0
  3021.             ;;
  3022.             
  3023.         ACCEPT)
  3024.             # do we have any options for this accept?
  3025.             if [ ! -z "${action_param[0]}" ]
  3026.             then
  3027.                 # find the options we have
  3028.                 case "${action_param[0]}" in
  3029.                     "limit")
  3030.                         # limit NEW connections to the specified rate
  3031.                         local freq="${action_param[1]}"
  3032.                         local burst="${action_param[2]}"
  3033.                         local overflow="REJECT"
  3034.                         
  3035.                         # if we have a custom overflow action, parse it.
  3036.                         test "${action_param[3]}" = "overflow" && local overflow="`echo "${action_param[4]}" | tr "a-z" "A-Z"`"
  3037.                         
  3038.                         # unset the action_param, so that if this rule does not include NEW connections,
  3039.                         # we will not append anything to the generated iptables statements.
  3040.                         local -a action_param=()
  3041.                         
  3042.                         # find is this rule matches NEW connections
  3043.                         local has_new=`echo "${state}" | grep -i NEW`
  3044.                         local do_accept_limit=0
  3045.                         if [ -z "${statenot}" ]
  3046.                         then
  3047.                             test ! -z "${has_new}" && local do_accept_limit=1
  3048.                         else
  3049.                             test -z "${has_new}" && local do_accept_limit=1
  3050.                         fi
  3051.                         
  3052.                         # we have a match for NEW connections.
  3053.                         # redirect the traffic to a new chain, which will control
  3054.                         # the NEW connections while allowing all the other traffic
  3055.                         # to pass.
  3056.                         if [ "${do_accept_limit}" = "1" ]
  3057.                         then
  3058.                             local accept_limit_chain="`echo "ACCEPT ${freq} ${burst} ${overflow}" | tr " /." "___"`"
  3059.                             
  3060.                             # does the chain we need already exist?
  3061.                             if [ ! -f "${FIREHOL_CHAINS_DIR}/${accept_limit_chain}" ]
  3062.                             then
  3063.                                 # the chain does not exist. create it.
  3064.                                 iptables ${table} -N "${accept_limit_chain}"
  3065.                                 touch "${FIREHOL_CHAINS_DIR}/${accept_limit_chain}"
  3066.                                 
  3067.                                 # first, if the traffic is not a NEW connection, allow it.
  3068.                                 # doing this first will speed up normal traffic.
  3069.                                 iptables ${table} -A "${accept_limit_chain}" -m state ! --state NEW -j ACCEPT
  3070.                                 
  3071.                                 # accept NEW connections within the given limits.
  3072.                                 iptables ${table} -A "${accept_limit_chain}" -m limit --limit "${freq}" --limit-burst "${burst}" -j ACCEPT
  3073.                                 
  3074.                                 # log the overflow NEW connections reaching this step within the new chain
  3075.                                 local -a logopts_arg=()
  3076.                                 if [ "${FIREHOL_LOG_MODE}" = "ULOG" ]
  3077.                                 then
  3078.                                     local -a logopts_arg=("--ulog-prefix='OVERFLOW:'")
  3079.                                 else
  3080.                                     local -a logopts_arg=("--log-level" "${FIREHOL_LOG_LEVEL}" "--log-prefix='OVERFLOW:'")
  3081.                                 fi
  3082.                                 iptables ${table} -A "${accept_limit_chain}" -m limit --limit "${FIREHOL_LOG_FREQUENCY}" --limit-burst "${FIREHOL_LOG_BURST}" -j ${FIREHOL_LOG_MODE} ${FIREHOL_LOG_OPTIONS} "${logopts_arg[@]}"
  3083.                                 
  3084.                                 # if the overflow is to be rejected is tcp, reject it with TCP-RESET
  3085.                                 if [ "${overflow}" = "REJECT" ]
  3086.                                 then
  3087.                                     iptables ${table} -A "${accept_limit_chain}" -p tcp -j REJECT --reject-with tcp-reset
  3088.                                 fi
  3089.                                 
  3090.                                 # do the specified action on the overflow
  3091.                                 iptables ${table} -A "${accept_limit_chain}" -j ${overflow}
  3092.                             fi
  3093.                             
  3094.                             # send the rule to be generated to this chain
  3095.                             local action=${accept_limit_chain}
  3096.                         fi
  3097.                         ;;
  3098.                         
  3099.                     'knock')
  3100.                         # the name of the knock
  3101.                         local name="knock_${action_param[1]}"
  3102.                         
  3103.                         # unset the action_param, so that if this rule does not include NEW connections,
  3104.                         # we will not append anything to the generated iptables statements.
  3105.                         local -a action_param=()
  3106.                         
  3107.                         # does the knock chain exists?
  3108.                         if [ ! -f "${FIREHOL_CHAINS_DIR}/${name}" ]
  3109.                         then
  3110.                             # the chain does not exist. create it.
  3111.                             iptables ${table} -N "${name}"
  3112.                             touch "${FIREHOL_CHAINS_DIR}/${name}"
  3113.                             
  3114.                             iptables -A "${name}" -m state --state ESTABLISHED -j ACCEPT
  3115.                             
  3116.                             # knockd (http://www.zeroflux.org/knock/)
  3117.                             # will create more rules inside this chain to match NEW packets.
  3118.                         fi
  3119.                         
  3120.                         # send the rule to be generated to this knock chain
  3121.                         local action=${name}
  3122.                         ;;
  3123.                         
  3124.                     *)
  3125.                         error "Internal error. Cannot understand action ${action} with parameter '${action_param[0]}'."
  3126.                         return 1
  3127.                         ;;
  3128.                 esac
  3129.             fi
  3130.             ;;
  3131.             
  3132.         REJECT)
  3133.             if [ "${action_param[1]}" = "auto" ]
  3134.             then
  3135.                 if [ "${protocol}" = "tcp" -o "${protocol}" = "TCP" ]
  3136.                 then
  3137.                     action_param=("--reject-with" "tcp-reset")
  3138.                 else
  3139.                     action_param=()
  3140.                 fi
  3141.             fi
  3142.             ;;
  3143.     esac
  3144.     
  3145.     iptables "$@" -j "${action}" "${action_param[@]}"
  3146.     local ret=$?
  3147.     
  3148.     test $ret -gt 0 && failed=$[failed + 1]
  3149.     
  3150.     return $ret
  3151. }
  3152.  
  3153. rule() {
  3154.     local table=
  3155.     local chain=
  3156.     
  3157.     local inface=any
  3158.     local infacenot=
  3159.     
  3160.     local outface=any
  3161.     local outfacenot=
  3162.     
  3163.     local physin=any
  3164.     local physinnot=
  3165.     
  3166.     local physout=any
  3167.     local physoutnot=
  3168.     
  3169.     local mac=any
  3170.     local macnot=
  3171.     
  3172.     local src=any
  3173.     local srcnot=
  3174.     
  3175.     local dst=any
  3176.     local dstnot=
  3177.     
  3178.     local sport=any
  3179.     local sportnot=
  3180.     
  3181.     local dport=any
  3182.     local dportnot=
  3183.     
  3184.     local proto=any
  3185.     local protonot=
  3186.     
  3187.     local uid=any
  3188.     local uidnot=
  3189.     
  3190.     local gid=any
  3191.     local gidnot=
  3192.     
  3193.     local pid=any
  3194.     local pidnot=
  3195.     
  3196.     local sid=any
  3197.     local sidnot=
  3198.     
  3199.     local cmd=any
  3200.     local cmdnot=
  3201.     
  3202.     local mark=any
  3203.     local marknot=
  3204.     
  3205.     local dscp=any
  3206.     local dscptype=
  3207.     local despnot=
  3208.     
  3209.     local tos=any
  3210.     local tosnot=
  3211.     
  3212.     local log=
  3213.     local logtxt=
  3214.     local loglevel=
  3215.     
  3216.     local limit=
  3217.     local burst=
  3218.     
  3219.     local iplimit=
  3220.     local iplimit_mask=
  3221.     
  3222.     local action=
  3223.     
  3224.     local state=
  3225.     local statenot=
  3226.     
  3227.     local failed=0
  3228.     local reverse=0
  3229.     
  3230.     local swi=0
  3231.     local swo=0
  3232.     
  3233.     local custom=
  3234.     
  3235.     # if set to 1, all owner module options will be ignored
  3236.     local noowner=0
  3237.     
  3238.     # if set to 1, all mac options will be ignored
  3239.     local nomac=0
  3240.     
  3241.     # if set to 1, MIRROR will be converted to REJECT
  3242.     local nomirror=0
  3243.     
  3244.     # if set to 1, log and loglimit are ignored.
  3245.     local nolog=0
  3246.     
  3247.     # if set to 1, detection algorithm about overwritting optional rule
  3248.     # parameters will take place.
  3249.     local softwarnings=1
  3250.     
  3251.     # set it, in order to be local
  3252.     local -a action_param=()
  3253.     
  3254.     while [ ! -z "${1}" ]
  3255.     do
  3256.         case "${1}" in
  3257.             reverse|REVERSE)
  3258.                 reverse=1
  3259.                 shift
  3260.                 ;;
  3261.                 
  3262.             table|TABLE)
  3263.                 test ${softwarnings} -eq 1 -a ! -z "${table}" && softwarning "Overwritting param: ${1} '${chain}' becomes '${2}'"
  3264.                 table="-t ${2}"
  3265.                 shift 2
  3266.                 ;;
  3267.                 
  3268.             chain|CHAIN)
  3269.                 test ${softwarnings} -eq 1 -a ! -z "${chain}" && softwarning "Overwritting param: ${1} '${chain}' becomes '${2}'"
  3270.                 chain="${2}"
  3271.                 shift 2
  3272.                 ;;
  3273.                 
  3274.             inface|INFACE)
  3275.                 shift
  3276.                 if [ ${reverse} -eq 0 ]
  3277.                 then
  3278.                     infacenot=
  3279.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3280.                     then
  3281.                         shift
  3282.                         infacenot="!"
  3283.                     else
  3284.                         if [ $swi -eq 1 ]
  3285.                         then
  3286.                             work_inface="${1}"
  3287.                         fi
  3288.                     fi
  3289.                     test ${softwarnings} -eq 1 -a ! "${inface}" = "any" && softwarning "Overwritting param: inface '${inface}' becomes '${1}'"
  3290.                     inface="${1}"
  3291.                 else
  3292.                     outfacenot=
  3293.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3294.                     then
  3295.                         shift
  3296.                         outfacenot="!"
  3297.                     else
  3298.                         if [ ${swo} -eq 1 ]
  3299.                         then
  3300.                             work_outface="$1"
  3301.                         fi
  3302.                     fi
  3303.                     test ${softwarnings} -eq 1 -a ! "${outface}" = "any" && softwarning "Overwritting param: outface '${outface}' becomes '${1}'"
  3304.                     outface="${1}"
  3305.                 fi
  3306.                 shift
  3307.                 ;;
  3308.                 
  3309.             outface|OUTFACE)
  3310.                 shift
  3311.                 if [ ${reverse} -eq 0 ]
  3312.                 then
  3313.                     outfacenot=
  3314.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3315.                     then
  3316.                         shift
  3317.                         outfacenot="!"
  3318.                     else
  3319.                         if [ ${swo} -eq 1 ]
  3320.                         then
  3321.                             work_outface="${1}"
  3322.                         fi
  3323.                     fi
  3324.                     test ${softwarnings} -eq 1 -a ! "${outface}" = "any" && softwarning "Overwritting param: outface '${outface}' becomes '${1}'"
  3325.                     outface="${1}"
  3326.                 else
  3327.                     infacenot=
  3328.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3329.                     then
  3330.                         shift
  3331.                         infacenot="!"
  3332.                     else
  3333.                         if [ ${swi} -eq 1 ]
  3334.                         then
  3335.                             work_inface="${1}"
  3336.                         fi
  3337.                     fi
  3338.                     test ${softwarnings} -eq 1 -a ! "${inface}" = "any" && softwarning "Overwritting param: inface '${inface}' becomes '${1}'"
  3339.                     inface="${1}"
  3340.                 fi
  3341.                 shift
  3342.                 ;;
  3343.                 
  3344.             physin|PHYSIN)
  3345.                 shift
  3346.                 if [ ${reverse} -eq 0 ]
  3347.                 then
  3348.                     physinnot=
  3349.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3350.                     then
  3351.                         shift
  3352.                         physinnot="!"
  3353.                     fi
  3354.                     test ${softwarnings} -eq 1 -a ! "${physin}" = "any" && softwarning "Overwritting param: physin '${physin}' becomes '${1}'"
  3355.                     physin="${1}"
  3356.                 else
  3357.                     physoutnot=
  3358.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3359.                     then
  3360.                         shift
  3361.                         physoutnot="!"
  3362.                     fi
  3363.                     test ${softwarnings} -eq 1 -a ! "${physout}" = "any" && softwarning "Overwritting param: physout '${physout}' becomes '${1}'"
  3364.                     physout="${1}"
  3365.                 fi
  3366.                 shift
  3367.                 ;;
  3368.                 
  3369.             physout|PHYSOUT)
  3370.                 shift
  3371.                 if [ ${reverse} -eq 0 ]
  3372.                 then
  3373.                     physoutnot=
  3374.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3375.                     then
  3376.                         shift
  3377.                         physoutnot="!"
  3378.                     fi
  3379.                     test ${softwarnings} -eq 1 -a ! "${physout}" = "any" && softwarning "Overwritting param: physout '${physout}' becomes '${1}'"
  3380.                     physout="${1}"
  3381.                 else
  3382.                     physinnot=
  3383.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3384.                     then
  3385.                         shift
  3386.                         physinnot="!"
  3387.                     fi
  3388.                     test ${softwarnings} -eq 1 -a ! "${physin}" = "any" && softwarning "Overwritting param: physin '${physin}' becomes '${1}'"
  3389.                     physin="${1}"
  3390.                 fi
  3391.                 shift
  3392.                 ;;
  3393.                 
  3394.             mac|MAC)
  3395.                 shift
  3396.                 macnot=
  3397.                 if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3398.                 then
  3399.                     shift
  3400.                     macnot="!"
  3401.                 fi
  3402.                 test ${softwarnings} -eq 1 -a ! "${mac}" = "any" && softwarning "Overwritting param: mac '${mac}' becomes '${1}'"
  3403.                 test ${nomac} -eq 0 && mac="${1}"
  3404.                 shift
  3405.                 ;;
  3406.                 
  3407.             src|SRC|source|SOURCE)
  3408.                 shift
  3409.                 if [ ${reverse} -eq 0 ]
  3410.                 then
  3411.                     srcnot=
  3412.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3413.                     then
  3414.                         shift
  3415.                         srcnot="!"
  3416.                     fi
  3417.                     test ${softwarnings} -eq 1 -a ! "${src}" = "any" && softwarning "Overwritting param: src '${src}' becomes '${1}'"
  3418.                     src="${1}"
  3419.                 else
  3420.                     dstnot=
  3421.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3422.                     then
  3423.                         shift
  3424.                         dstnot="!"
  3425.                     fi
  3426.                     test ${softwarnings} -eq 1 -a ! "${dst}" = "any" && softwarning "Overwritting param: dst '${dst}' becomes '${1}'"
  3427.                     dst="${1}"
  3428.                 fi
  3429.                 shift
  3430.                 ;;
  3431.                 
  3432.             dst|DST|destination|DESTINATION)
  3433.                 shift
  3434.                 if [ ${reverse} -eq 0 ]
  3435.                 then
  3436.                     dstnot=
  3437.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3438.                     then
  3439.                         shift
  3440.                         dstnot="!"
  3441.                     fi
  3442.                     test ${softwarnings} -eq 1 -a ! "${dst}" = "any" && softwarning "Overwritting param: dst '${dst}' becomes '${1}'"
  3443.                     dst="${1}"
  3444.                 else
  3445.                     srcnot=
  3446.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3447.                     then
  3448.                         shift
  3449.                         srcnot="!"
  3450.                     fi
  3451.                     test ${softwarnings} -eq 1 -a ! "${src}" = "any" && softwarning "Overwritting param: src '${src}' becomes '${1}'"
  3452.                     src="${1}"
  3453.                 fi
  3454.                 shift
  3455.                 ;;
  3456.                 
  3457.             sport|SPORT|sourceport|SOURCEPORT)
  3458.                 shift
  3459.                 if [ ${reverse} -eq 0 ]
  3460.                 then
  3461.                     sportnot=
  3462.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3463.                     then
  3464.                         shift
  3465.                         sportnot="!"
  3466.                     fi
  3467.                     test ${softwarnings} -eq 1 -a ! "${sport}" = "any" && softwarning "Overwritting param: sport '${sport}' becomes '${1}'"
  3468.                     sport="${1}"
  3469.                 else
  3470.                     dportnot=
  3471.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3472.                     then
  3473.                         shift
  3474.                         dportnot="!"
  3475.                     fi
  3476.                     test ${softwarnings} -eq 1 -a ! "${dport}" = "any" && softwarning "Overwritting param: dport '${dport}' becomes '${1}'"
  3477.                     dport="${1}"
  3478.                 fi
  3479.                 shift
  3480.                 ;;
  3481.                 
  3482.             dport|DPORT|destinationport|DESTINATIONPORT)
  3483.                 shift
  3484.                 if [ ${reverse} -eq 0 ]
  3485.                 then
  3486.                     dportnot=
  3487.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3488.                     then
  3489.                         shift
  3490.                         dportnot="!"
  3491.                     fi
  3492.                     test ${softwarnings} -eq 1 -a ! "${dport}" = "any" && softwarning "Overwritting param: dport '${dport}' becomes '${1}'"
  3493.                     dport="${1}"
  3494.                 else
  3495.                     sportnot=
  3496.                     if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3497.                     then
  3498.                         shift
  3499.                         sportnot="!"
  3500.                     fi
  3501.                     test ${softwarnings} -eq 1 -a ! "${sport}" = "any" && softwarning "Overwritting param: sport '${sport}' becomes '${1}'"
  3502.                     sport="${1}"
  3503.                 fi
  3504.                 shift
  3505.                 ;;
  3506.                 
  3507.             proto|PROTO|protocol|PROTOCOL)
  3508.                 shift
  3509.                 protonot=
  3510.                 if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3511.                 then
  3512.                     shift
  3513.                     protonot="!"
  3514.                 fi
  3515.                 test ${softwarnings} -eq 1 -a ! "${proto}" = "any" && softwarning "Overwritting param: proto '${proto}' becomes '${1}'"
  3516.                 proto="${1}"
  3517.                 shift
  3518.                 ;;
  3519.                 
  3520.             mark|MARK)
  3521.                 shift
  3522.                 marknot=
  3523.                 if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3524.                 then
  3525.                     shift
  3526.                     marknot="!"
  3527.                 fi
  3528.                 test ${softwarnings} -eq 1 -a ! "${mark}" = "any" && softwarning "Overwritting param: mark '${mark}' becomes '${1}'"
  3529.                 mark="${1}"
  3530.                 shift
  3531.                 ;;
  3532.                 
  3533.             tos|TOS)
  3534.                 shift
  3535.                 tosnot=
  3536.                 if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3537.                 then
  3538.                     shift
  3539.                     tosnot="!"
  3540.                 fi
  3541.                 test ${softwarnings} -eq 1 -a ! "${tos}" = "any" && softwarning "Overwritting param: tos '${tos}' becomes '${1}'"
  3542.                 tos="${1}"
  3543.                 shift
  3544.                 ;;
  3545.                 
  3546.             dscp|DSCP)
  3547.                 shift
  3548.                 dscpnot=
  3549.                 if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3550.                 then
  3551.                     shift
  3552.                     dscpnot="!"
  3553.                 fi
  3554.                 test ${softwarnings} -eq 1 -a ! "${dscp}" = "any" && softwarning "Overwritting param: dscp '${dscp}' becomes '${1}'"
  3555.                 dscp="${1}"
  3556.                 shift
  3557.                 
  3558.                 if [ "${dscp}" = "class" ]
  3559.                 then
  3560.                     dscptype="-class"
  3561.                     dscp="${1}"
  3562.                     shift
  3563.                 fi
  3564.                 ;;
  3565.                 
  3566.             action|ACTION)
  3567.                 test ${softwarnings} -eq 1 -a ! -z "${action}" && softwarning "Overwritting param: action '${action}' becomes '${2}'"
  3568.                 action="${2}"
  3569.                 shift 2
  3570.                 
  3571.                 local -a action_param=()
  3572.                 local action_is_chain=0
  3573.                 case "${action}" in
  3574.                     accept|ACCEPT)
  3575.                         action="ACCEPT"
  3576.                         
  3577.                         if [ "${1}" = "with" ]
  3578.                         then
  3579.                             shift
  3580.                             
  3581.                             case "${1}" in
  3582.                                 limit|LIMIT)
  3583.                                     local -a action_param=("limit" "${2}" "${3}")
  3584.                                     shift 3
  3585.                                     
  3586.                                     if [ "${1}" = "overflow" ]
  3587.                                     then
  3588.                                         action_param[3]="overflow"
  3589.                                         action_param[4]="${2}"
  3590.                                         shift 2
  3591.                                     fi
  3592.                                     ;;
  3593.                                 
  3594.                                 knock|KNOCK)
  3595.                                     local -a action_param=("knock" "${2}")
  3596.                                     shift 2
  3597.                                     ;;
  3598.                                 
  3599.                                 *)
  3600.                                     error "Cannot understand action's '${action}' directive '${1}'"
  3601.                                     return 1
  3602.                                     ;;
  3603.                             esac
  3604.                         fi
  3605.                         ;;
  3606.                         
  3607.                     deny|DENY|drop|DROP)
  3608.                         action="DROP"
  3609.                         ;;
  3610.                         
  3611.                     reject|REJECT)
  3612.                         action="REJECT"
  3613.                         if [ "${1}" = "with" ]
  3614.                         then
  3615.                             local -a action_param=("--reject-with" "${2}")
  3616.                             shift 2
  3617.                         else
  3618.                             local -a action_param=("--reject-with" "auto")
  3619.                         fi
  3620.                         ;;
  3621.                         
  3622.                     return|RETURN)
  3623.                         action="RETURN"
  3624.                         ;;
  3625.                         
  3626.                     mirror|MIRROR)
  3627.                         action="MIRROR"
  3628.                         test $nomirror -eq 1 && action="REJECT"
  3629.                         ;;
  3630.                         
  3631.                     none|NONE)
  3632.                         action="NONE"
  3633.                         ;;
  3634.                         
  3635.                     snat|SNAT)
  3636.                         action="SNAT"
  3637.                         if [ "${1}" = "to" ]
  3638.                         then
  3639.                             local -a action_param=()
  3640.                             local x=
  3641.                             for x in ${2}
  3642.                             do
  3643.                                 action_param=(${action_param[@]} "--to-source" "${x}")
  3644.                             done
  3645.                             shift 2
  3646.                         else
  3647.                             error "${action} requires a 'to' argument."
  3648.                             return 1
  3649.                         fi
  3650.                         if [ ! "A${table}" = "A-t nat" ]
  3651.                         then
  3652.                             error "${action} must on a the 'nat' table."
  3653.                             return 1
  3654.                         fi
  3655.                         ;;
  3656.                         
  3657.                     dnat|DNAT)
  3658.                         action="DNAT"
  3659.                         if [ "${1}" = "to" ]
  3660.                         then
  3661.                             local -a action_param=()
  3662.                             local x=
  3663.                             for x in ${2}
  3664.                             do
  3665.                                 action_param=(${action_param[@]} "--to-destination" "${x}")
  3666.                             done
  3667.                             shift 2
  3668.                         else
  3669.                             error "${action} requires a 'to' argument"
  3670.                             return 1
  3671.                         fi
  3672.                         if [ ! "A${table}" = "A-t nat" ]
  3673.                         then
  3674.                             error "${action} must on a the 'nat' table."
  3675.                             return 1
  3676.                         fi
  3677.                         ;;
  3678.                         
  3679.                     redirect|REDIRECT)
  3680.                         action="REDIRECT"
  3681.                         if [ "${1}" = "to-port" -o "${1}" = "to" ]
  3682.                         then
  3683.                             local -a action_param=("--to-ports" "${2}")
  3684.                             shift 2
  3685.                         else
  3686.                             error "${action} requires a 'to-port' or 'to' argument."
  3687.                             return 1
  3688.                         fi
  3689.                         if [ ! "A${table}" = "A-t nat" ]
  3690.                         then
  3691.                             error "${action} must on a the 'nat' table."
  3692.                             return 1
  3693.                         fi
  3694.                         ;;
  3695.                         
  3696.                     tos|TOS)
  3697.                         action="TOS"
  3698.                         if [ "${1}" = "to" ]
  3699.                         then
  3700.                             local -a action_param=("--set-tos" "${2}")
  3701.                             shift 2
  3702.                         else
  3703.                             error "${action} requires a 'to' argument"
  3704.                             return 1
  3705.                         fi
  3706.                         if [ ! "A${table}" = "A-t mangle" ]
  3707.                         then
  3708.                             error "${action} must on a the 'mangle' table."
  3709.                             return 1
  3710.                         fi
  3711.                         ;;
  3712.                         
  3713.                     mark|MARK)
  3714.                         action="MARK"
  3715.                         if [ "${1}" = "to" ]
  3716.                         then
  3717.                             local -a action_param=("--set-mark" "${2}")
  3718.                             shift 2
  3719.                         else
  3720.                             error "${action} requires a 'to' argument"
  3721.                             return 1
  3722.                         fi
  3723.                         if [ ! "A${table}" = "A-t mangle" ]
  3724.                         then
  3725.                             error "${action} must on a the 'mangle' table."
  3726.                             return 1
  3727.                         fi
  3728.                         ;;
  3729.                         
  3730.                     dscp|DSCP)
  3731.                         action="DSCP"
  3732.                         if [ "${1}" = "to" ]
  3733.                         then
  3734.                             if [ "${2}" = "class" ]
  3735.                             then
  3736.                                 local -a action_param=("--set-dscp-class" "${2}")
  3737.                                 shift
  3738.                             else
  3739.                                 local -a action_param=("--set-dscp" "${2}")
  3740.                             fi
  3741.                             shift 2
  3742.                         else
  3743.                             error "${action} requires a 'to' argument"
  3744.                             return 1
  3745.                         fi
  3746.                         if [ ! "A${table}" = "A-t mangle" ]
  3747.                         then
  3748.                             error "${action} must on a the 'mangle' table."
  3749.                             return 1
  3750.                         fi
  3751.                         ;;
  3752.                         
  3753.                     *)
  3754.                         chain_exists "${action}"
  3755.                         local action_is_chain=$?
  3756.                         ;;
  3757.                 esac
  3758.                 ;;
  3759.             
  3760.             state|STATE)
  3761.                 shift
  3762.                 statenot=
  3763.                 if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3764.                 then
  3765.                     shift
  3766.                     statenot="!"
  3767.                 fi
  3768.                 test ${softwarnings} -eq 1 -a ! -z "${state}" && softwarning "Overwritting param: state '${state}' becomes '${1}'"
  3769.                 state="${1}"
  3770.                 shift
  3771.                 ;;
  3772.                 
  3773.             user|USER|uid|UID)
  3774.                 shift
  3775.                 uidnot=
  3776.                 if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3777.                 then
  3778.                     shift
  3779.                     test ${noowner} -eq 0 && uidnot="!"
  3780.                 fi
  3781.                 test ${softwarnings} -eq 1 -a ! "${uid}" = "any" && softwarning "Overwritting param: uid '${uid}' becomes '${1}'"
  3782.                 test ${noowner} -eq 0 && uid="${1}"
  3783.                 shift
  3784.                 ;;
  3785.                 
  3786.             group|GROUP|gid|GID)
  3787.                 shift
  3788.                 gidnot=
  3789.                 if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3790.                 then
  3791.                     shift
  3792.                     test ${noowner} -eq 0 && gidnot="!"
  3793.                 fi
  3794.                 test ${softwarnings} -eq 1 -a ! "${gid}" = "any" && softwarning "Overwritting param: gid '${gid}' becomes '${1}'"
  3795.                 test ${noowner} -eq 0 && gid="${1}"
  3796.                 shift
  3797.                 ;;
  3798.                 
  3799.             process|PROCESS|pid|PID)
  3800.                 shift
  3801.                 pidnot=
  3802.                 if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3803.                 then
  3804.                     shift
  3805.                     test ${noowner} -eq 0 && pidnot="!"
  3806.                 fi
  3807.                 test ${softwarnings} -eq 1 -a ! "${pid}" = "any" && softwarning "Overwritting param: pid '${pid}' becomes '${1}'"
  3808.                 test ${noowner} -eq 0 && pid="${1}"
  3809.                 shift
  3810.                 ;;
  3811.                 
  3812.             session|SESSION|sid|SID)
  3813.                 shift
  3814.                 sidnot=
  3815.                 if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3816.                 then
  3817.                     shift
  3818.                     test ${noowner} -eq 0 && sidnot="!"
  3819.                 fi
  3820.                 test ${softwarnings} -eq 1 -a ! "${sid}" = "any" && softwarning "Overwritting param: sid '${sid}' becomes '${1}'"
  3821.                 test ${noowner} -eq 0 && sid="${1}"
  3822.                 shift
  3823.                 ;;
  3824.                 
  3825.             command|COMMAND|cmd|CMD)
  3826.                 shift
  3827.                 cmdnot=
  3828.                 if [ "${1}" = "not" -o "${1}" = "NOT" ]
  3829.                 then
  3830.                     shift
  3831.                     test ${noowner} -eq 0 && cmdnot="!"
  3832.                 fi
  3833.                 test ${softwarnings} -eq 1 -a ! "${cmd}" = "any" && softwarning "Overwritting param: cmd '${cmd}' becomes '${1}'"
  3834.                 test ${noowner} -eq 0 && cmd="${1}"
  3835.                 shift
  3836.                 ;;
  3837.                 
  3838.             custom|CUSTOM)
  3839.                 test ${softwarnings} -eq 1 -a ! -z "${custom}" && softwarning "Overwritting param: custom '${custom}' becomes '${2}'"
  3840.                 custom="${2}"
  3841.                 shift 2
  3842.                 ;;
  3843.                 
  3844.             log|LOG)
  3845.                 if [ ${nolog} -eq 0 ]
  3846.                 then
  3847.                     test ${softwarnings} -eq 1 -a ! -z "${log}" && softwarning "Overwritting param: log '${log}/${logtxt}' becomes 'normal/${2}'"
  3848.                     log=normal
  3849.                     logtxt="${2}"
  3850.                 fi
  3851.                 shift 2
  3852.                 if [ "${1}" = "level" ]
  3853.                 then
  3854.                     loglevel="${2}"
  3855.                     shift 2
  3856.                 else
  3857.                     loglevel="${FIREHOL_LOG_LEVEL}"
  3858.                 fi
  3859.                 ;;
  3860.                 
  3861.             loglimit|LOGLIMIT)
  3862.                 if [ ${nolog} -eq 0 ]
  3863.                 then
  3864.                     test ${softwarnings} -eq 1 -a ! -z "${log}" && softwarning "Overwritting param: log '${log}/${logtxt}' becomes 'limit/${2}'"
  3865.                     log=limit
  3866.                     logtxt="${2}"
  3867.                 fi
  3868.                 shift 2
  3869.                 if [ "${1}" = "level" ]
  3870.                 then
  3871.                     loglevel="${2}"
  3872.                     shift 2
  3873.                 else
  3874.                     loglevel="${FIREHOL_LOG_LEVEL}"
  3875.                 fi
  3876.                 ;;
  3877.                 
  3878.             limit|LIMIT)
  3879.                 test ${softwarnings} -eq 1 -a ! -z "${limit}" && softwarning "Overwritting param: limit '${limit}' becomes '${2}'"
  3880.                 limit="${2}"
  3881.                 burst="${3}"
  3882.                 shift 3
  3883.                 ;;
  3884.                 
  3885.             iplimit|IPLIMIT)
  3886.                 test ${softwarnings} -eq 1 -a ! -z "${iplimit}" && softwarning "Overwritting param: iplimit '${iplimit}' becomes '${2}'"
  3887.                 iplimit="${2}"
  3888.                 iplimit_mask="${3}"
  3889.                 shift 3
  3890.                 ;;
  3891.                 
  3892.             in)    # this is incoming traffic - ignore packet ownership
  3893.                 local noowner=1
  3894.                 local nomirror=0
  3895.                 local nomac=0
  3896.                 shift
  3897.                 ;;
  3898.                 
  3899.             out)    # this is outgoing traffic - ignore packet ownership if not in an interface
  3900.                 if [ ! "${work_cmd}" = "interface" ]
  3901.                 then
  3902.                     local noowner=1
  3903.                 else
  3904.                     local nomirror=1
  3905.                 fi
  3906.                 local nomac=1
  3907.                 shift
  3908.                 ;;
  3909.                 
  3910.             nolog)
  3911.                 local nolog=1
  3912.                 shift
  3913.                 ;;
  3914.                 
  3915.             noowner)
  3916.                 local noowner=1
  3917.                 shift
  3918.                 ;;
  3919.                 
  3920.             softwarnings)
  3921.                 local softwarnings=1
  3922.                 shift
  3923.                 ;;
  3924.                 
  3925.             nosoftwarnings)
  3926.                 local softwarnings=0
  3927.                 shift
  3928.                 ;;
  3929.                 
  3930.             set_work_inface|SET_WORK_INFACE)
  3931.                 swi=1
  3932.                 shift
  3933.                 ;;
  3934.                 
  3935.             set_work_outface|SET_WORK_OUTFACE)
  3936.                 swo=1
  3937.                 shift
  3938.                 ;;
  3939.                 
  3940.             *)
  3941.                 error "Cannot understand directive '${1}'."
  3942.                 return 1
  3943.                 ;;
  3944.         esac
  3945.     done
  3946.     
  3947.     test -z "${table}" && table="-t filter"
  3948.     
  3949.     # If the user did not specified a rejection message,
  3950.     # we have to be smart and produce a tcp-reset if the protocol
  3951.     # is TCP and an ICMP port unreachable in all other cases.
  3952.     # The special case here is the protocol "any".
  3953.     # To accomplish the differentiation based on protocol we have
  3954.     # to change the protocol "any" to "tcp any"
  3955.     
  3956.     test "${action}" = "REJECT" -a "${action_param[1]}" = "auto" -a "${proto}" = "any" && proto="tcp any"
  3957.     
  3958.     
  3959.     # we cannot accept empty strings to a few parameters, since this
  3960.     # will prevent us from generating a rule (due to nested BASH loops).
  3961.     test -z "${inface}"    && error "Cannot accept an empty 'inface'."    && return 1
  3962.     test -z "${outface}"    && error "Cannot accept an empty 'outface'."    && return 1
  3963.     test -z "${physin}"    && error "Cannot accept an empty 'physin'."    && return 1
  3964.     test -z "${physout}"    && error "Cannot accept an empty 'physout'."    && return 1
  3965.     test -z "${mac}"    && error "Cannot accept an empty 'mac'."    && return 1
  3966.     test -z "${src}"    && error "Cannot accept an empty 'src'."    && return 1
  3967.     test -z "${dst}"    && error "Cannot accept an empty 'dst'."    && return 1
  3968.     test -z "${sport}"    && error "Cannot accept an empty 'sport'."    && return 1
  3969.     test -z "${dport}"    && error "Cannot accept an empty 'dport'."    && return 1
  3970.     test -z "${proto}"    && error "Cannot accept an empty 'proto'."    && return 1
  3971.     test -z "${uid}"    && error "Cannot accept an empty 'uid'."    && return 1
  3972.     test -z "${gid}"    && error "Cannot accept an empty 'gid'."    && return 1
  3973.     test -z "${pid}"    && error "Cannot accept an empty 'pid'."    && return 1
  3974.     test -z "${sid}"    && error "Cannot accept an empty 'sid'."    && return 1
  3975.     test -z "${cmd}"    && error "Cannot accept an empty 'cmd'."    && return 1
  3976.     
  3977.     
  3978.     # ----------------------------------------------------------------------------------
  3979.     # Do we have negative contitions?
  3980.     # If yes, we have to:
  3981.     #
  3982.     # case 1: If the action is a chain.
  3983.     #         Add to this chain positive RETURN statements matching all the negatives.
  3984.     #         The positive rules will be added bellow to the same chain and will be
  3985.     #         matched only if all RETURNs have not been matched.
  3986.     #
  3987.     # case 2: If the action is not a chain.
  3988.     #         Create a temporary chain, then add to this chain positive RETURN rules
  3989.     #         matching the negatives, and append at its end the final action (which is
  3990.     #         not a chain), then change the action of the positive rules to jump to
  3991.     #         this temporary chain.
  3992.     
  3993.     
  3994.     # ignore 'statenot' since it is negated in the positive rules
  3995.     if [ ! -z "${infacenot}${outfacenot}${physinnot}${physoutnot}${macnot}${srcnot}${dstnot}${sportnot}${dportnot}${protonot}${uidnot}${gidnot}${pidnot}${sidnot}${cmdnot}${marknot}${tosnot}${dscpnot}" ]
  3996.     then
  3997.         if [ ${action_is_chain} -eq 1 ]
  3998.         then
  3999.             # if the action is a chain name, then just add the negative
  4000.             # expressions to this chain. Nothing more.
  4001.             
  4002.             local negative_chain="${action}"
  4003.             local negative_action=
  4004.         else
  4005.             # if the action is a native iptables action, then create
  4006.             # an intermidiate chain to store the negative expression,
  4007.             # and change the action of the rule to point to this action.
  4008.             
  4009.             # In this case, bellow we add after all negatives, the original
  4010.             # action of the rule.
  4011.             
  4012.             local negative_chain="${chain}.${FIREHOL_DYNAMIC_CHAIN_COUNTER}"
  4013.             FIREHOL_DYNAMIC_CHAIN_COUNTER="$[FIREHOL_DYNAMIC_CHAIN_COUNTER + 1]"
  4014.             
  4015.             iptables ${table} -N "${negative_chain}"
  4016.             local negative_action="${action}"
  4017.             local action="${negative_chain}"
  4018.         fi
  4019.         
  4020.         
  4021.         if [ ! -z "${infacenot}" ]
  4022.         then
  4023.             local inf=
  4024.             for inf in ${inface}
  4025.             do
  4026.                 iptables ${table} -A "${negative_chain}" -i "${inf}" -j RETURN
  4027.             done
  4028.             infacenot=
  4029.             inface=any
  4030.         fi
  4031.     
  4032.         if [ ! -z "${outfacenot}" ]
  4033.         then
  4034.             local outf=
  4035.             for outf in ${outface}
  4036.             do
  4037.                 iptables ${table} -A "${negative_chain}" -o "${outf}" -j RETURN
  4038.             done
  4039.             outfacenot=
  4040.             outface=any
  4041.         fi
  4042.         
  4043.         if [ ! -z "${physinnot}" ]
  4044.         then
  4045.             local inph=
  4046.             for inph in ${physin}
  4047.             do
  4048.                 iptables ${table} -A "${negative_chain}" -m physdev --physdev-in "${inph}" -j RETURN
  4049.             done
  4050.             physinnot=
  4051.             physin=any
  4052.         fi
  4053.     
  4054.         if [ ! -z "${physoutnot}" ]
  4055.         then
  4056.             local outph=
  4057.             for outph in ${physout}
  4058.             do
  4059.                 iptables ${table} -A "${negative_chain}" -m physdev --physdev-out "${outph}" -j RETURN
  4060.             done
  4061.             physoutnot=
  4062.             physout=any
  4063.         fi
  4064.         
  4065.         if [ ! -z "${macnot}" ]
  4066.         then
  4067.             local m=
  4068.             for m in ${mac}
  4069.             do
  4070.                 iptables ${table} -A "${negative_chain}" -m mac --mac-source "${m}" -j RETURN
  4071.             done
  4072.             macnot=
  4073.             mac=any
  4074.         fi
  4075.         
  4076.         if [ ! -z "${srcnot}" ]
  4077.         then
  4078.             local s=
  4079.             for s in ${src}
  4080.             do
  4081.                 iptables ${table} -A "${negative_chain}" -s "${s}" -j RETURN
  4082.             done
  4083.             srcnot=
  4084.             src=any
  4085.         fi
  4086.         
  4087.         if [ ! -z "${dstnot}" ]
  4088.         then
  4089.             local d=
  4090.             for d in ${dst}
  4091.             do
  4092.                 iptables ${table} -A "${negative_chain}" -d "${d}" -j RETURN
  4093.             done
  4094.             dstnot=
  4095.             dst=any
  4096.         fi
  4097.         
  4098.         if [ ! -z "${protonot}" ]
  4099.         then
  4100.             if [ ! -z "${sportnot}" -o ! -z "${dportnot}" ]
  4101.             then
  4102.                 error "Cannot have negative protocol(s) and source/destination port(s)."
  4103.                 return 1
  4104.             fi
  4105.             
  4106.             local pr=
  4107.             for pr in ${proto}
  4108.             do
  4109.                 iptables ${table} -A "${negative_chain}" -p "${pr}" -j RETURN
  4110.             done
  4111.             protonot=
  4112.             proto=any
  4113.         fi
  4114.         
  4115.         if [ ! -z "${sportnot}" ]
  4116.         then
  4117.             if [ "${proto}" = "any" ]
  4118.             then
  4119.                 error "Cannot have negative source port specification without protocol."
  4120.                 return 1
  4121.             fi
  4122.             
  4123.             local sp=
  4124.             for sp in ${sport}
  4125.             do
  4126.                 local pr=
  4127.                 for pr in ${proto}
  4128.                 do
  4129.                     iptables ${table} -A "${negative_chain}" -p "${pr}" --sport "${sp}" -j RETURN
  4130.                 done
  4131.             done
  4132.             sportnot=
  4133.             sport=any
  4134.         fi
  4135.         
  4136.         if [ ! -z "${dportnot}" ]
  4137.         then
  4138.             if [ "${proto}" = "any" ]
  4139.             then
  4140.                 error "Cannot have negative destination port specification without protocol."
  4141.                 return 1
  4142.             fi
  4143.             
  4144.             local dp=
  4145.             for dp in ${dport}
  4146.             do
  4147.                 local pr=
  4148.                 for pr in ${proto}
  4149.                 do
  4150.                     iptables ${table} -A "${negative_chain}" -p "${pr}" --dport "${dp}" -j RETURN
  4151.                 done
  4152.             done
  4153.             dportnot=
  4154.             dport=any
  4155.         fi
  4156.         
  4157.         if [ ! -z "${uidnot}" ]
  4158.         then
  4159.             local tuid=
  4160.             for tuid in ${uid}
  4161.             do
  4162.                 iptables ${table} -A "${negative_chain}" -m owner --uid-owner "${tuid}" -j RETURN
  4163.             done
  4164.             uidnot=
  4165.             uid=any
  4166.         fi
  4167.         
  4168.         if [ ! -z "${gidnot}" ]
  4169.         then
  4170.             local tgid=
  4171.             for tgid in ${gid}
  4172.             do
  4173.                 iptables ${table} -A "${negative_chain}" -m owner --gid-owner "${tgid}" -j RETURN
  4174.             done
  4175.             gidnot=
  4176.             gid=any
  4177.         fi
  4178.         
  4179.         if [ ! -z "${pidnot}" ]
  4180.         then
  4181.             local tpid=
  4182.             for tpid in ${pid}
  4183.             do
  4184.                 iptables ${table} -A "${negative_chain}" -m owner --pid-owner "${tpid}" -j RETURN
  4185.             done
  4186.             pidnot=
  4187.             pid=any
  4188.         fi
  4189.         
  4190.         if [ ! -z "${sidnot}" ]
  4191.         then
  4192.             local tsid=
  4193.             for tsid in ${sid}
  4194.             do
  4195.                 iptables ${table} -A "${negative_chain}" -m owner --sid-owner "${tsid}" -j RETURN
  4196.             done
  4197.             sidnot=
  4198.             sid=any
  4199.         fi
  4200.         
  4201.         if [ ! -z "${cmdnot}" ]
  4202.         then
  4203.             local tcmd=
  4204.             for tcmd in ${cmd}
  4205.             do
  4206.                 iptables ${table} -A "${negative_chain}" -m owner --cmd-owner "${tcmd}" -j RETURN
  4207.             done
  4208.             cmdnot=
  4209.             cmd=any
  4210.         fi
  4211.         
  4212.         if [ ! -z "${marknot}" ]
  4213.         then
  4214.             local tmark=
  4215.             for tmark in ${mark}
  4216.             do
  4217.                 iptables ${table} -A "${negative_chain}" -m mark --mark "${tmark}" -j RETURN
  4218.             done
  4219.             marknot=
  4220.             mark=any
  4221.         fi
  4222.         
  4223.         if [ ! -z "${tosnot}" ]
  4224.         then
  4225.             local ttos=
  4226.             for ttos in ${tos}
  4227.             do
  4228.                 iptables ${table} -A "${negative_chain}" -m tos --tos "${ttos}" -j RETURN
  4229.             done
  4230.             tosnot=
  4231.             tos=any
  4232.         fi
  4233.         
  4234.         if [ ! -z "${dscpnot}" ]
  4235.         then
  4236.             local tdscp=
  4237.             for tdscp in ${dscp}
  4238.             do
  4239.                 iptables ${table} -A "${negative_chain}" -m dscp --dscp${dscptype} "${tdscp}" -j RETURN
  4240.             done
  4241.             dscp=any
  4242.             dscpnot=
  4243.         fi
  4244.         
  4245.         
  4246.         # in case this is temporary chain we created for the negative expression,
  4247.         # just make it have the final action of the rule.
  4248.         if [ ! -z "${negative_action}" ]
  4249.         then
  4250.             local pr=
  4251.             for pr in ${proto}
  4252.             do
  4253.                 local -a proto_arg=()
  4254.                 
  4255.                 case ${pr} in
  4256.                     any|ANY)
  4257.                         ;;
  4258.                     
  4259.                     *)
  4260.                         local -a proto_arg=("-p" "${pr}")
  4261.                         ;;
  4262.                 esac
  4263.                 
  4264.                 rule_action_param "${negative_action}" "${pr}" "" "" "${table}" "${action_param[@]}" -- ${table} -A "${negative_chain}" "${proto_arg[@]}"
  4265.                 local -a action_param=()
  4266.             done
  4267.         fi
  4268.     fi
  4269.     
  4270.     
  4271.     # ----------------------------------------------------------------------------------
  4272.     # Process the positive rules
  4273.     
  4274.     # uid
  4275.     local tuid=
  4276.     for tuid in ${uid}
  4277.     do
  4278.         local -a uid_arg=()
  4279.         local -a owner_arg=()
  4280.         
  4281.         case ${tuid} in
  4282.             any|ANY)
  4283.                 ;;
  4284.             
  4285.             *)
  4286.                 local -a owner_arg=("-m" "owner")
  4287.                 local -a uid_arg=("--uid-owner" "${tuid}")
  4288.                 ;;
  4289.         esac
  4290.     
  4291.     # gid
  4292.     local tgid=
  4293.     for tgid in ${gid}
  4294.     do
  4295.         local -a gid_arg=()
  4296.         
  4297.         case ${tgid} in
  4298.             any|ANY)
  4299.                 ;;
  4300.             
  4301.             *)
  4302.                 local -a owner_arg=("-m" "owner")
  4303.                 local -a gid_arg=("--gid-owner" "${tgid}")
  4304.                 ;;
  4305.         esac
  4306.     
  4307.     # pid
  4308.     local tpid=
  4309.     for tpid in ${pid}
  4310.     do
  4311.         local -a pid_arg=()
  4312.         
  4313.         case ${tpid} in
  4314.             any|ANY)
  4315.                 ;;
  4316.             
  4317.             *)
  4318.                 local -a owner_arg=("-m" "owner")
  4319.                 local -a pid_arg=("--pid-owner" "${tpid}")
  4320.                 ;;
  4321.         esac
  4322.     
  4323.     # sid
  4324.     local tsid=
  4325.     for tsid in ${sid}
  4326.     do
  4327.         local -a sid_arg=()
  4328.         
  4329.         case ${tsid} in
  4330.             any|ANY)
  4331.                 ;;
  4332.             
  4333.             *)
  4334.                 local -a owner_arg=("-m" "owner")
  4335.                 local -a sid_arg=("--sid-owner" "${tsid}")
  4336.                 ;;
  4337.         esac
  4338.     
  4339.     # cmd
  4340.     local tcmd=
  4341.     for tcmd in ${cmd}
  4342.     do
  4343.         local -a cmd_arg=()
  4344.         
  4345.         case ${tcmd} in
  4346.             any|ANY)
  4347.                 ;;
  4348.             
  4349.             *)
  4350.                 local -a owner_arg=("-m" "owner")
  4351.                 local -a cmd_arg=("--cmd-owner" "${tcmd}")
  4352.                 ;;
  4353.         esac
  4354.     
  4355.     # mark
  4356.     local tmark=
  4357.     for tmark in ${mark}
  4358.     do
  4359.         local -a mark_arg=()
  4360.         
  4361.         case ${tmark} in
  4362.             any|ANY)
  4363.                 ;;
  4364.             
  4365.             *)
  4366.                 local -a mark_arg=("-m" "mark" "--mark" "${tmark}")
  4367.                 ;;
  4368.         esac
  4369.     
  4370.     # tos
  4371.     local ttos=
  4372.     for ttos in ${tos}
  4373.     do
  4374.         local -a tos_arg=()
  4375.         
  4376.         case ${ttos} in
  4377.             any|ANY)
  4378.                 ;;
  4379.             
  4380.             *)
  4381.                 local -a tos_arg=("-m" "tos" "--tos" "${ttos}")
  4382.                 ;;
  4383.         esac
  4384.     
  4385.     # dscp
  4386.     local tdscp=
  4387.     for tdscp in ${dscp}
  4388.     do
  4389.         local -a dscp_arg=()
  4390.         
  4391.         case ${tdscp} in
  4392.             any|ANY)
  4393.                 ;;
  4394.             
  4395.             *)
  4396.                 local -a dscp_arg=("-m" "dscp" "--dscp${dscptype}" "${tdscp}")
  4397.                 ;;
  4398.         esac
  4399.     
  4400.     # proto
  4401.     local pr=
  4402.     for pr in ${proto}
  4403.     do
  4404.         local -a proto_arg=()
  4405.         
  4406.         case ${pr} in
  4407.             any|ANY)
  4408.                 ;;
  4409.             
  4410.             *)
  4411.                 local -a proto_arg=("-p" "${pr}")
  4412.                 ;;
  4413.         esac
  4414.     
  4415.     # inface
  4416.     local inf=
  4417.     for inf in ${inface}
  4418.     do
  4419.         local -a inf_arg=()
  4420.         case ${inf} in
  4421.             any|ANY)
  4422.                 ;;
  4423.             
  4424.             *)
  4425.                 local -a inf_arg=("-i" "${inf}")
  4426.                 ;;
  4427.         esac
  4428.     
  4429.     # outface
  4430.     local outf=
  4431.     for outf in ${outface}
  4432.     do
  4433.         local -a outf_arg=()
  4434.         case ${outf} in
  4435.             any|ANY)
  4436.                 ;;
  4437.             
  4438.             *)
  4439.                 local -a outf_arg=("-o" "${outf}")
  4440.                 ;;
  4441.         esac
  4442.     
  4443.     # physin
  4444.     local inph=
  4445.     for inph in ${physin}
  4446.     do
  4447.         local -a inph_arg=()
  4448.         case ${inph} in
  4449.             any|ANY)
  4450.                 ;;
  4451.             
  4452.             *)
  4453.                 local -a physdev_arg=("-m" "physdev")
  4454.                 local -a inph_arg=("--physdev-in" "${inph}")
  4455.                 ;;
  4456.         esac
  4457.     
  4458.     # physout
  4459.     local outph=
  4460.     for outph in ${physout}
  4461.     do
  4462.         local -a outph_arg=()
  4463.         case ${outph} in
  4464.             any|ANY)
  4465.                 ;;
  4466.             
  4467.             *)
  4468.                 local -a physdev_arg=("-m" "physdev")
  4469.                 local -a outph_arg=("--physdev-out" "${outph}")
  4470.                 ;;
  4471.         esac
  4472.     
  4473.     # sport
  4474.     local sp=
  4475.     for sp in ${sport}
  4476.     do
  4477.         local -a sp_arg=()
  4478.         case ${sp} in
  4479.             any|ANY)
  4480.                 ;;
  4481.             
  4482.             *)
  4483.                 local -a sp_arg=("--sport" "${sp}")
  4484.                 ;;
  4485.         esac
  4486.     
  4487.     # dport
  4488.     local dp=
  4489.     for dp in ${dport}
  4490.     do
  4491.         local -a dp_arg=()
  4492.         case ${dp} in
  4493.             any|ANY)
  4494.                 ;;
  4495.             
  4496.             *)
  4497.                 local -a dp_arg=("--dport" "${dp}")
  4498.                 ;;
  4499.         esac
  4500.     
  4501.     # mac
  4502.     local mc=
  4503.     for mc in ${mac}
  4504.     do
  4505.         local -a mc_arg=()
  4506.         case ${mc} in
  4507.             any|ANY)
  4508.                 ;;
  4509.             
  4510.             *)
  4511.                 local -a mc_arg=("-m" "mac" "--mac-source" "${mc}")
  4512.                 ;;
  4513.         esac
  4514.     
  4515.     # src
  4516.     local s=
  4517.     for s in ${src}
  4518.     do
  4519.         local -a s_arg=()
  4520.         case ${s} in
  4521.             any|ANY)
  4522.                 ;;
  4523.             
  4524.             *)
  4525.                 local -a s_arg=("-s" "${s}")
  4526.                 ;;
  4527.         esac
  4528.     
  4529.     # dst
  4530.     local d=
  4531.     for d in ${dst}
  4532.     do
  4533.         local -a d_arg=()
  4534.         case ${d} in
  4535.             any|ANY)
  4536.                 ;;
  4537.             
  4538.             *)
  4539.                 local -a d_arg=("-d" "${d}")
  4540.                 ;;
  4541.         esac
  4542.     
  4543.     # state
  4544.     local -a state_arg=()
  4545.     if [ ! -z "${state}" ]
  4546.     then
  4547.         local -a state_arg=("-m" "state" "${statenot}" "--state" "${state}")
  4548.     fi
  4549.     
  4550.     # limit
  4551.     local -a limit_arg=()
  4552.     if [ ! -z "${limit}" ]
  4553.     then
  4554.         local -a limit_arg=("-m" "limit" "--limit" "${limit}" "--limit-burst" "${burst}")
  4555.     fi
  4556.     
  4557.     # iplimit
  4558.     local -a iplimit_arg=()
  4559.     if [ ! -z "${iplimit}" ]
  4560.     then
  4561.         local -a iplimit_arg=("-m" "iplimit" "--iplimit-above" "${iplimit}" "--iplimit-mask" "${iplimit_mask}")
  4562.     fi
  4563.     
  4564.     # build the command
  4565.     declare -a basecmd=("${inf_arg[@]}" "${outf_arg[@]}" "${physdev_arg[@]}" "${inph_arg[@]}" "${outph_arg[@]}" "${limit_arg[@]}" "${iplimit_arg[@]}" "${proto_arg[@]}" "${s_arg[@]}" "${sp_arg[@]}" "${d_arg[@]}" "${dp_arg[@]}" "${owner_arg[@]}" "${uid_arg[@]}" "${gid_arg[@]}" "${pid_arg[@]}" "${sid_arg[@]}" "${cmd_arg[@]}" "${state_arg[@]}" "${mc_arg[@]}" "${mark_arg[@]}" "${tos_arg[@]}" "${dscp_arg[@]}")
  4566.     
  4567.     # log mode selection
  4568.     local -a logopts_arg=()
  4569.     if [ "${FIREHOL_LOG_MODE}" = "ULOG" ]
  4570.     then
  4571.         local -a logopts_arg=("--ulog-prefix='${logtxt}:'")
  4572.     else
  4573.         local -a logopts_arg=("--log-level" "${loglevel}" "--log-prefix='${logtxt}:'")
  4574.     fi
  4575.     
  4576.     # log / loglimit
  4577.     case "${log}" in
  4578.         '')
  4579.             ;;
  4580.         
  4581.         limit)
  4582.             iptables ${table} -A "${chain}" "${basecmd[@]}" ${custom} -m limit --limit "${FIREHOL_LOG_FREQUENCY}" --limit-burst "${FIREHOL_LOG_BURST}" -j ${FIREHOL_LOG_MODE} ${FIREHOL_LOG_OPTIONS} "${logopts_arg[@]}"
  4583.             ;;
  4584.             
  4585.         normal)
  4586.             iptables ${table} -A "${chain}" "${basecmd[@]}" ${custom}  -j ${FIREHOL_LOG_MODE} ${FIREHOL_LOG_OPTIONS} "${logopts_arg[@]}"
  4587.             ;;
  4588.             
  4589.         *)
  4590.             error "Unknown log value '${log}'."
  4591.             ;;
  4592.     esac
  4593.     
  4594.     # do it!
  4595.     rule_action_param "${action}" "${pr}" "${statenot}" "${state}" "${table}" "${action_param[@]}" -- ${table} -A "${chain}" "${basecmd[@]}" ${custom}
  4596.     
  4597.     done # dst
  4598.     done # src
  4599.     done # mac
  4600.     done # dport
  4601.     done # sport
  4602.     done # physout
  4603.     done # physin
  4604.     done # outface
  4605.     done # inface
  4606.     done # proto
  4607.     done # dscp
  4608.     done # tos
  4609.     done # mark
  4610.     done # cmd
  4611.     done # sid
  4612.     done # pid
  4613.     done # gid
  4614.     done # uid
  4615.     
  4616.     test ${failed} -gt 0 && error "There are ${failed} failed commands." && return 1
  4617.     return 0
  4618. }
  4619.  
  4620.  
  4621. softwarning() {
  4622.     echo >&2
  4623.     echo >&2 "--------------------------------------------------------------------------------"
  4624.     echo >&2 "WARNING"
  4625.     echo >&2 "WHAT   : ${work_function}"
  4626.     echo >&2 "WHY    :" "$@"
  4627.     printf >&2 "COMMAND: "; printf >&2 "%q " "${work_realcmd[@]}"; echo >&2
  4628.     echo >&2 "SOURCE : line ${FIREHOL_LINEID} of ${FIREHOL_CONFIG}"
  4629.     echo >&2
  4630.     
  4631.     return 0
  4632. }
  4633.  
  4634. # ------------------------------------------------------------------------------
  4635. # error - error reporting while still parsing the configuration file
  4636. # WHY:
  4637. # This is the error handler that presents to the user detected errors during
  4638. # processing FireHOL's configuration file.
  4639. # This command is directly called by other functions of FireHOL.
  4640.  
  4641. error() {
  4642.     work_error=$[work_error + 1]
  4643.     echo >&2
  4644.     echo >&2 "--------------------------------------------------------------------------------"
  4645.     echo >&2 "ERROR #: ${work_error}"
  4646.     echo >&2 "WHAT   : ${work_function}"
  4647.     echo >&2 "WHY    :" "$@"
  4648.     printf >&2 "COMMAND: "; printf >&2 "%q " "${work_realcmd[@]}"; echo >&2
  4649.     echo >&2 "SOURCE : line ${FIREHOL_LINEID} of ${FIREHOL_CONFIG}"
  4650.     echo >&2
  4651.     
  4652.     return 0
  4653. }
  4654.  
  4655.  
  4656. # ------------------------------------------------------------------------------
  4657. # runtime_error - postprocessing evaluation of commands run
  4658. # WHY:
  4659. # The generated iptables commands must be checked for errors in case they fail.
  4660. # This command is executed after every postprocessing command to find out
  4661. # if it has been successfull or failed.
  4662.  
  4663. runtime_error() {
  4664.     local type="ERROR"
  4665.     local id=
  4666.     
  4667.     case "${1}" in
  4668.         error)
  4669.             local type="ERROR  "
  4670.             work_final_status=$[work_final_status + 1]
  4671.             local id="# ${work_final_status}."
  4672.             ;;
  4673.             
  4674.         warn)
  4675.             local type="WARNING"
  4676.             local id="This might or might not affect the operation of your firewall."
  4677.             ;;
  4678.         
  4679.         *)
  4680.             work_final_status=$[work_final_status + 1]
  4681.             local id="# ${work_final_status}."
  4682.             
  4683.             echo >&2
  4684.             echo >&2
  4685.             echo >&2 "*** unsupported final status type '${1}'. Assuming it is 'ERROR'"
  4686.             echo >&2
  4687.             echo >&2
  4688.             ;;
  4689.     esac
  4690.     shift
  4691.     
  4692.     local ret="${1}"; shift
  4693.     local line="${1}"; shift
  4694.     
  4695.     echo >&2
  4696.     echo >&2
  4697.     echo >&2 "--------------------------------------------------------------------------------"
  4698.     echo >&2 "${type} : ${id}"
  4699.     echo >&2 "WHAT    : A runtime command failed to execute (returned error ${ret})."
  4700.     echo >&2 "SOURCE  : line ${line} of ${FIREHOL_CONFIG}"
  4701.     printf >&2 "COMMAND : "
  4702.     printf >&2 "%q " "$@"
  4703.     printf >&2 "\n"
  4704.     echo >&2 "OUTPUT  : "
  4705.     echo >&2
  4706.     ${CAT_CMD} ${FIREHOL_OUTPUT}.log
  4707.     echo >&2
  4708.     
  4709.     return 0
  4710. }
  4711.  
  4712.  
  4713. # ------------------------------------------------------------------------------
  4714. # chain_exists - find if chain name has already being specified
  4715. # WHY:
  4716. # We have to make sure each service gets its own chain.
  4717. # Although FireHOL chain naming makes chains with unique names, this is just
  4718. # an extra sanity check.
  4719.  
  4720. chain_exists() {
  4721.     local chain="${1}"
  4722.     
  4723.     test -f "${FIREHOL_CHAINS_DIR}/${chain}" && return 1
  4724.     return 0
  4725. }
  4726.  
  4727.  
  4728. # ------------------------------------------------------------------------------
  4729. # create_chain - create a chain and link it to the firewall
  4730. # WHY:
  4731. # When a chain is created it must somehow to be linked to the rest of the
  4732. # firewall apropriately. This function first creates the chain and then
  4733. # it links it to its final position within the generated firewall.
  4734.  
  4735. create_chain() {
  4736.     local table="${1}"
  4737.     local newchain="${2}"
  4738.     local oldchain="${3}"
  4739.     shift 3
  4740.     
  4741.     set_work_function "Creating chain '${newchain}' under '${oldchain}' in table '${table}'"
  4742.     
  4743.     chain_exists "${newchain}"
  4744.     test $? -eq 1 && error "Chain '${newchain}' already exists." && return 1
  4745.     
  4746.     iptables -t ${table} -N "${newchain}" || return 1
  4747.     ${TOUCH_CMD} "${FIREHOL_CHAINS_DIR}/${newchain}"
  4748.     
  4749.     rule table ${table} chain "${oldchain}" action "${newchain}" "$@" || return 1
  4750.     
  4751.     return 0
  4752. }
  4753.  
  4754.  
  4755. # ------------------------------------------------------------------------------
  4756. # smart_function - find the valid service definition for a service
  4757. # WHY:
  4758. # FireHOL supports simple and complex services. This function first tries to
  4759. # detect if there are the proper variables set for a simple service, and if
  4760. # they do not exist, it then tries to find the complex function definition for
  4761. # the service.
  4762. #
  4763. # Additionally, it creates a chain for the subcommand.
  4764.  
  4765. smart_function() {
  4766.     local type="${1}"    # The current subcommand: server/client/route
  4767.     local services="${2}"    # The services to implement
  4768.     shift 2
  4769.     
  4770.     local service=
  4771.     for service in $services
  4772.     do
  4773.         local servname="${service}"
  4774.         test "${service}" = "custom" && local servname="${1}"
  4775.         
  4776.         set_work_function "Preparing for service '${service}' of type '${type}' under interface '${work_name}'"
  4777.         
  4778.         # Increase the command counter, to make all chains within a primary
  4779.         # command, unique.
  4780.         work_counter=$[work_counter + 1]
  4781.         
  4782.         local suffix="u${work_counter}"
  4783.         case "${type}" in
  4784.             client)
  4785.                 suffix="c${work_counter}"
  4786.                 ;;
  4787.             
  4788.             server)
  4789.                 suffix="s${work_counter}"
  4790.                 ;;
  4791.             
  4792.             route)
  4793.                 suffix="r${work_counter}"
  4794.                 ;;
  4795.             
  4796.             *)    error "Cannot understand type '${type}'."
  4797.                 return 1
  4798.                 ;;
  4799.         esac
  4800.         
  4801.         local mychain="${work_name}_${servname}_${suffix}"
  4802.         
  4803.         create_chain filter "in_${mychain}" "in_${work_name}" || return 1
  4804.         create_chain filter "out_${mychain}" "out_${work_name}" || return 1
  4805.         
  4806.         # Try the simple services first
  4807.         simple_service "${mychain}" "${type}" "${service}" "$@"
  4808.         local ret=$?
  4809.         
  4810.         # simple service completed succesfully.
  4811.         test $ret -eq 0 && continue
  4812.         
  4813.         # simple service exists but failed.
  4814.         if [ $ret -ne 127 ]
  4815.         then
  4816.             error "Simple service '${service}' returned an error ($ret)."
  4817.             return 1
  4818.         fi
  4819.         
  4820.         
  4821.         # Try the custom services
  4822.         local fn="rules_${service}"
  4823.         
  4824.         set_work_function "Running complex rules function ${fn}() for ${type} '${service}'"
  4825.         
  4826.         "${fn}" "${mychain}" "${type}" "$@"
  4827.         local ret=$?
  4828.         test $ret -eq 0 && continue
  4829.         
  4830.         if [ $ret -eq 127 ]
  4831.         then
  4832.             error "There is no service '${service}' defined."
  4833.         else
  4834.             error "Complex service '${service}' returned an error ($ret)."
  4835.         fi
  4836.         return 1
  4837.     done
  4838.     
  4839.     return 0
  4840. }
  4841.  
  4842. # ------------------------------------------------------------------------------
  4843. # simple_service - convert a service definition to an inline service definition
  4844. # WHY:
  4845. # When a simple service is detected, there must be someone to call
  4846. # rules_custom() with the appropriate service definition parameters.
  4847.  
  4848. simple_service() {
  4849.     local mychain="${1}"; shift
  4850.     local type="${1}"; shift
  4851.     local server="${1}"; shift
  4852.     
  4853.     local server_varname="server_${server}_ports"
  4854.     eval local server_ports="\$${server_varname}"
  4855.     
  4856.     local client_varname="client_${server}_ports"
  4857.     eval local client_ports="\$${client_varname}"
  4858.     
  4859.     test -z "${server_ports}" -o -z "${client_ports}" && return 127
  4860.     
  4861.     local x=
  4862.     local varname="require_${server}_modules"
  4863.     eval local value="\$${varname}"
  4864.     for x in ${value}
  4865.     do
  4866.         require_kernel_module $x || return 1
  4867.     done
  4868.     
  4869.     if [ ${FIREHOL_NAT} -eq 1 ]
  4870.     then
  4871.         local varname="require_${server}_nat_modules"
  4872.         eval local value="\$${varname}"
  4873.         for x in ${value}
  4874.         do
  4875.             require_kernel_module $x || return 1
  4876.         done
  4877.     fi
  4878.     
  4879.     set_work_function "Running simple rules for  ${type} '${service}'"
  4880.     
  4881.     rules_custom "${mychain}" "${type}" "${server}" "${server_ports}" "${client_ports}" "$@"
  4882.     return $?
  4883. }
  4884.  
  4885. show_work_realcmd() {
  4886.     test ${FIREHOL_EXPLAIN} -eq 1 && return 0
  4887.     
  4888.     (
  4889.         printf "\n\n"
  4890.         printf "# === CONFIGURATION STATEMENT =================================================\n"
  4891.         printf "# CONF:%3s>>>    " ${FIREHOL_LINEID}
  4892.         
  4893.         case $1 in
  4894.             2)    printf "    "
  4895.                 ;;
  4896.             *)    ;;
  4897.         esac
  4898.         
  4899.         printf "%q " "${work_realcmd[@]}"
  4900.         printf "\n\n"
  4901.     ) >>${FIREHOL_OUTPUT}
  4902. }
  4903.  
  4904. work_realcmd_primary() {
  4905.     work_realcmd=("$@")
  4906.     test ${FIREHOL_CONF_SHOW} -eq 1 && show_work_realcmd 1
  4907. }
  4908.  
  4909. work_realcmd_secondary() {
  4910.     work_realcmd=("$@")
  4911.     test ${FIREHOL_CONF_SHOW} -eq 1 && show_work_realcmd 2
  4912. }
  4913.  
  4914. work_realcmd_helper() {    
  4915.     work_realcmd=("$@")
  4916.     test ${FIREHOL_CONF_SHOW} -eq 1 && show_work_realcmd 3
  4917. }
  4918.  
  4919.  
  4920.  
  4921. # ------------------------------------------------------------------------------
  4922. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  4923. # ------------------------------------------------------------------------------
  4924. #
  4925. # START UP SCRIPT PROCESSING
  4926. #
  4927. # ------------------------------------------------------------------------------
  4928. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  4929. # ------------------------------------------------------------------------------
  4930.  
  4931. # ------------------------------------------------------------------------------
  4932. # On non RedHat machines we need success() and failure()
  4933. success() {
  4934.     printf " OK"
  4935. }
  4936. failure() {
  4937.     echo " FAILED"
  4938. }
  4939.  
  4940. # ------------------------------------------------------------------------------
  4941. # A small part bellow is copied from /etc/init.d/iptables
  4942.  
  4943. # On RedHat systems this will define success() and failure()
  4944. test -f /etc/init.d/functions && . /etc/init.d/functions
  4945.  
  4946. if [ -z "${IPTABLES_CMD}" -o ! -x "${IPTABLES_CMD}" ]; then
  4947.     echo >&2 "Cannot find an executables iptables command."
  4948.     exit 0
  4949. fi
  4950.  
  4951. KERNELMAJ=`${UNAME_CMD} -r | ${SED_CMD}                   -e 's,\..*,,'`
  4952. KERNELMIN=`${UNAME_CMD} -r | ${SED_CMD} -e 's,[^\.]*\.,,' -e 's,\..*,,'`
  4953.  
  4954. if [ "$KERNELMAJ" -lt 2 ] ; then
  4955.     echo >&2 "FireHOL requires a kernel version higher than 2.3."
  4956.     exit 0
  4957. fi
  4958. if [ "$KERNELMAJ" -eq 2 -a "$KERNELMIN" -lt 3 ] ; then
  4959.     echo >&2 "FireHOL requires a kernel version higher than 2.3."
  4960.     exit 0
  4961. fi
  4962.  
  4963. if  ${LSMOD_CMD} 2>/dev/null | ${GREP_CMD} -q ipchains ; then
  4964.     # Don't do both
  4965.     echo >&2 "ipchains is loaded in the kernel. Please remove ipchains to run iptables."
  4966.     exit 0
  4967. fi
  4968.  
  4969.  
  4970. # ------------------------------------------------------------------------------
  4971. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  4972. # ------------------------------------------------------------------------------
  4973. #
  4974. # COMMAND LINE ARGUMENTS PROCESSING
  4975. #
  4976. # ------------------------------------------------------------------------------
  4977. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  4978. # ------------------------------------------------------------------------------
  4979.  
  4980. me="${0}"
  4981. arg="${1}"
  4982. shift
  4983.  
  4984. case "${arg}" in
  4985.     explain)
  4986.         test ! -z "${1}" && softwarning "Arguments after parameter '${arg}' are ignored."
  4987.         FIREHOL_EXPLAIN=1
  4988.         ;;
  4989.     
  4990.     helpme|wizard)
  4991.         test ! -z "${1}" && softwarning "Arguments after parameter '${arg}' are ignored."
  4992.         FIREHOL_WIZARD=1
  4993.         ;;
  4994.     
  4995.     try)
  4996.         test ! -z "${1}" && softwarning "Arguments after parameter '${arg}' are ignored."
  4997.         FIREHOL_TRY=1
  4998.         ;;
  4999.     
  5000.     start)
  5001.         test ! -z "${1}" && softwarning "Arguments after parameter '${arg}' are ignored."
  5002.         FIREHOL_TRY=0
  5003.         ;;
  5004.     
  5005.     stop)
  5006.         test ! -z "${1}" && softwarning "Arguments after parameter '${arg}' are ignored."
  5007.         
  5008.         test -f /var/lock/subsys/firehol && ${RM_CMD} -f /var/lock/subsys/firehol
  5009.         test -f /var/lock/subsys/iptables && ${RM_CMD} -f /var/lock/subsys/iptables
  5010.         
  5011.         echo -n $"FireHOL: Clearing Firewall:"
  5012.         load_kernel_module ip_tables
  5013.         tables=`${CAT_CMD} /proc/net/ip_tables_names`
  5014.         for t in ${tables}
  5015.         do
  5016.             ${IPTABLES_CMD} -t "${t}" -F
  5017.             ${IPTABLES_CMD} -t "${t}" -X
  5018.             ${IPTABLES_CMD} -t "${t}" -Z
  5019.             
  5020.             # Find all default chains in this table.
  5021.             chains=`${IPTABLES_CMD} -t "${t}" -nL | ${GREP_CMD} "^Chain " | ${CUT_CMD} -d ' ' -f 2`
  5022.             for c in ${chains}
  5023.             do
  5024.                 ${IPTABLES_CMD} -t "${t}" -P "${c}" ACCEPT
  5025.             done
  5026.         done
  5027.         success $"FireHOL: Clearing Firewall:"
  5028.         echo
  5029.         
  5030.         exit 0
  5031.         ;;
  5032.     
  5033.     restart|force-reload)
  5034.         test ! -z "${1}" && softwarning "Arguments after parameter '${arg}' are ignored."
  5035.         FIREHOL_TRY=0
  5036.         ;;
  5037.     
  5038.     condrestart)
  5039.         test ! -z "${1}" && softwarning "Arguments after parameter '${arg}' are ignored."
  5040.         FIREHOL_TRY=0
  5041.         if [ -f /var/lock/subsys/firehol ]
  5042.         then
  5043.             exit 0
  5044.         fi
  5045.         ;;
  5046.     
  5047.     status)
  5048.         test ! -z "${1}" && softwarning "Arguments after parameter '${arg}' are ignored."
  5049.         (
  5050.             echo 
  5051.             echo "--- MANGLE ---------------------------------------------------------------------"
  5052.             echo 
  5053.             ${IPTABLES_CMD} -t mangle -nxvL
  5054.             
  5055.             echo 
  5056.             echo 
  5057.             echo "--- NAT ------------------------------------------------------------------------"
  5058.             echo 
  5059.             ${IPTABLES_CMD} -t nat -nxvL
  5060.             
  5061.             echo 
  5062.             echo 
  5063.             echo "--- FILTER ---------------------------------------------------------------------"
  5064.             echo 
  5065.             ${IPTABLES_CMD} -nxvL
  5066.         ) | ${LESS_CMD}
  5067.         exit $?
  5068.         ;;
  5069.     
  5070.     panic)
  5071.         ssh_src=
  5072.         ssh_sport="0:65535"
  5073.         ssh_dport="0:65535"
  5074.         if [ ! -z "${SSH_CLIENT}" ]
  5075.         then
  5076.             set -- ${SSH_CLIENT}
  5077.             ssh_src="${1}"
  5078.             ssh_sport="${2}"
  5079.             ssh_dport="${3}"
  5080.         elif [ ! -z "${1}" ]
  5081.         then
  5082.             ssh_src="${1}"
  5083.         fi
  5084.         
  5085.         echo -n $"FireHOL: Blocking all communications:"
  5086.         load_kernel_module ip_tables
  5087.         tables=`${CAT_CMD} /proc/net/ip_tables_names`
  5088.         for t in ${tables}
  5089.         do
  5090.             ${IPTABLES_CMD} -t "${t}" -F
  5091.             ${IPTABLES_CMD} -t "${t}" -X
  5092.             ${IPTABLES_CMD} -t "${t}" -Z
  5093.             
  5094.             # Find all default chains in this table.
  5095.             chains=`${IPTABLES_CMD} -t "${t}" -nL | ${GREP_CMD} "^Chain " | ${CUT_CMD} -d ' ' -f 2`
  5096.             for c in ${chains}
  5097.             do
  5098.                 ${IPTABLES_CMD} -t "${t}" -P "${c}" ACCEPT
  5099.                 
  5100.                 if [ ! -z "${ssh_src}" ]
  5101.                 then
  5102.                     ${IPTABLES_CMD} -t "${t}" -A "${c}" -p tcp -s "${ssh_src}" --sport "${ssh_sport}" --dport "${ssh_dport}" -m state --state ESTABLISHED -j ACCEPT
  5103.                     ${IPTABLES_CMD} -t "${t}" -A "${c}" -p tcp -d "${ssh_src}" --dport "${ssh_sport}" --sport "${ssh_dport}" -m state --state ESTABLISHED -j ACCEPT
  5104.                 fi
  5105.                 ${IPTABLES_CMD} -t "${t}" -A "${c}" -j DROP
  5106.             done
  5107.         done
  5108.         success $"FireHOL: Blocking all communications:"
  5109.         echo
  5110.         
  5111.         exit 0
  5112.         ;;
  5113.     
  5114.     save)
  5115.         test ! -z "${1}" && softwarning "Arguments after parameter '${arg}' are ignored."
  5116.         FIREHOL_TRY=0
  5117.         FIREHOL_SAVE=1
  5118.         ;;
  5119.         
  5120.     debug)
  5121.         test ! -z "${1}" && softwarning "Arguments after parameter '${arg}' are ignored."
  5122.         FIREHOL_TRY=0
  5123.         FIREHOL_DEBUG=1
  5124.         ;;
  5125.     
  5126.     *)    if [ ! -z "${arg}" -a -f "${arg}" ]
  5127.         then
  5128.             FIREHOL_CONFIG="${arg}"
  5129.             arg="${1}"
  5130.             test "${arg}" = "--" && arg="" && shift
  5131.             test -z "${arg}" && arg="try"
  5132.             
  5133.             case "${arg}" in
  5134.                 start)
  5135.                     FIREHOL_TRY=0
  5136.                     FIREHOL_DEBUG=0
  5137.                     ;;
  5138.                     
  5139.                 try)
  5140.                     FIREHOL_TRY=1
  5141.                     FIREHOL_DEBUG=0
  5142.                     ;;
  5143.                     
  5144.                 debug)
  5145.                     FIREHOL_TRY=0
  5146.                     FIREHOL_DEBUG=1
  5147.                     ;;
  5148.                 
  5149.                 *)
  5150.                     echo "Cannot accept command line argument '${arg}' here."
  5151.                     exit 1
  5152.                     ;;
  5153.             esac
  5154.         else
  5155.         
  5156.         ${CAT_CMD} <<EOF
  5157. $Id: firehol.sh,v 1.226 2005/01/25 21:28:19 ktsaou Exp $
  5158. (C) Copyright 2003, Costa Tsaousis <costa@tsaousis.gr>
  5159. FireHOL is distributed under GPL.
  5160.  
  5161. EOF
  5162.  
  5163.         ${CAT_CMD} <<EOF
  5164. FireHOL supports the following command line arguments (only one of them):
  5165.  
  5166.     start        to activate the firewall configuration.
  5167.             The configuration is expected to be found in
  5168.             ${FIREHOL_CONFIG_DIR}/firehol.conf
  5169.             
  5170.     try        to activate the firewall, but wait until
  5171.             the user types the word "commit". If this word
  5172.             is not typed within 30 seconds, the previous
  5173.             firewall is restored.
  5174.             
  5175.     stop        to stop a running iptables firewall.
  5176.             This will allow all traffic to pass unchecked.
  5177.         
  5178.     restart        this is an alias for start and is given for
  5179.             compatibility with /etc/init.d/iptables.
  5180.             
  5181.     condrestart    will start the firewall only if it is not
  5182.             already active. It does not detect a modified
  5183.             configuration file.
  5184.     
  5185.     status        will show the running firewall, as in:
  5186.             ${IPTABLES_CMD} -nxvL | ${LESS_CMD}
  5187.             
  5188.     panic        will block all IP communication.
  5189.     
  5190.     save        to start the firewall and then save it to the
  5191.             place where /etc/init.d/iptables looks for it.
  5192.             
  5193.             Note that not all firewalls will work if
  5194.             restored with:
  5195.             /etc/init.d/iptables start
  5196.             
  5197.     debug        to parse the configuration file but instead of
  5198.             activating it, to show the generated iptables
  5199.             statements.
  5200.     
  5201.     explain        to enter interactive mode and accept configuration
  5202.             directives. It also gives the iptables commands
  5203.             for each directive together with reasoning.
  5204.             
  5205.     helpme    or    to enter a wizard mode where FireHOL will try
  5206.     wizard        to figure out the configuration you need.
  5207.             You can redirect the standard output of FireHOL to
  5208.             a file to get the config to this file.
  5209.             
  5210.     <a filename>    a different configuration file.
  5211.             If not other argument is given, the configuration
  5212.             will be "tried" (default = try).
  5213.             Otherwise the argument next to the filename can
  5214.             be one of 'start', 'debug' and 'try'.
  5215.  
  5216.  
  5217. -------------------------------------------------------------------------
  5218.  
  5219. FireHOL supports the following services (sorted by name):
  5220. EOF
  5221.  
  5222.  
  5223.         (
  5224.             # The simple services
  5225.             ${CAT_CMD} "${me}"                |\
  5226.                 ${GREP_CMD} -e "^server_.*_ports="    |\
  5227.                 ${CUT_CMD} -d '=' -f 1            |\
  5228.                 ${SED_CMD} "s/^server_//"        |\
  5229.                 ${SED_CMD} "s/_ports\$//"
  5230.             
  5231.             # The complex services
  5232.             ${CAT_CMD} "${me}"                |\
  5233.                 ${GREP_CMD} -e "^rules_.*()"        |\
  5234.                 ${CUT_CMD} -d '(' -f 1            |\
  5235.                 ${SED_CMD} "s/^rules_/(*) /"
  5236.         ) | ${SORT_CMD} | ${UNIQ_CMD} |\
  5237.         (
  5238.             x=0
  5239.             while read
  5240.             do
  5241.                 x=$[x + 1]
  5242.                 if [ $x -gt 4 ]
  5243.                 then
  5244.                     printf "\n"
  5245.                     x=1
  5246.                 fi
  5247.                 printf "% 16s |" "$REPLY"
  5248.             done
  5249.             printf "\n\n"
  5250.         )
  5251.         
  5252.         ${CAT_CMD} <<EOF
  5253.  
  5254. Services marked with (*) are "smart" or complex services.
  5255. All the others are simple single socket services.
  5256.  
  5257. Please note that the service:
  5258.     
  5259.     all    matches all packets, all protocols, all of everything,
  5260.         while ensuring that required kernel modules are loaded.
  5261.     
  5262.     any    allows the matching of packets with unusual rules, like
  5263.         only protocol but no ports. If service any is used
  5264.         without other parameters, it does what service all does
  5265.         but it does not handle kernel modules.
  5266.         For example, to match GRE traffic use:
  5267.         
  5268.         server any mygre accept proto 47
  5269.         
  5270.         Service any does not handle kernel modules.
  5271.         
  5272.     custom    allows the definition of a custom service.
  5273.         The template is:
  5274.         
  5275.         server custom name protocol/sport cport accept
  5276.         
  5277.         where name is just a name, protocol is the protocol the
  5278.         service uses (tcp, udp, etc), sport is server port,
  5279.         cport is the client port. For example, IMAP4 is:
  5280.         
  5281.         server custom imap tcp/143 default accept
  5282.  
  5283.  
  5284. For more information about FireHOL, please refer to:
  5285.  
  5286.         http://firehol.sourceforge.net
  5287.  
  5288. -------------------------------------------------------------------------
  5289. FireHOL controls your firewall. You should want to get updates quickly.
  5290. Subscribe (at the home page) to get notified of new releases.
  5291. -------------------------------------------------------------------------
  5292.  
  5293. YOU DO NOT KNOW WHAT TO DO? FireHOL can help you! Just run it with the
  5294. argument 'helpme' and it will generate its configuration file for this
  5295. machine. Your running firewall will not be altered or stopped, and no
  5296. systems settings will be modified. Just run:
  5297.  
  5298. ${FIREHOL_FILE} helpme >/tmp/firehol.conf
  5299.  
  5300. and you will get the configuration written to /tmp/firehol.conf
  5301.  
  5302. EOF
  5303.         exit 1
  5304.         
  5305.         fi
  5306.         ;;
  5307. esac
  5308.  
  5309. # Remove the next arg if it is --
  5310. test "${1}" = "--" && shift
  5311.  
  5312. if [ ${FIREHOL_EXPLAIN} -eq 0 -a ${FIREHOL_WIZARD} -eq 0 -a ! -f "${FIREHOL_CONFIG}" ]
  5313. then
  5314.     echo -n $"FireHOL config ${FIREHOL_CONFIG} not found:"
  5315.     failure $"FireHOL config ${FIREHOL_CONFIG} not found:"
  5316.     echo
  5317.     exit 1
  5318. fi
  5319.  
  5320.  
  5321. # ------------------------------------------------------------------------------
  5322. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  5323. # ------------------------------------------------------------------------------
  5324. #
  5325. # MAIN PROCESSING - Interactive mode
  5326. #
  5327. # ------------------------------------------------------------------------------
  5328. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  5329. # ------------------------------------------------------------------------------
  5330.  
  5331. if [ ${FIREHOL_EXPLAIN} -eq 1 ]
  5332. then
  5333.     FIREHOL_CONFIG="Interactive User Input"
  5334.     FIREHOL_LINEID="1"
  5335.     
  5336.     FIREHOL_TEMP_CONFIG="${FIREHOL_DIR}/firehol.conf"
  5337.     
  5338.     echo "version ${FIREHOL_VERSION}" >"${FIREHOL_TEMP_CONFIG}"
  5339.     version ${FIREHOL_VERSION}
  5340.     
  5341.     ${CAT_CMD} <<EOF
  5342.  
  5343. $Id: firehol.sh,v 1.226 2005/01/25 21:28:19 ktsaou Exp $
  5344. (C) Copyright 2003, Costa Tsaousis <costa@tsaousis.gr>
  5345. FireHOL is distributed under GPL.
  5346. Home Page: http://firehol.sourceforge.net
  5347.  
  5348. --------------------------------------------------------------------------------
  5349. FireHOL controls your firewall. You should want to get updates quickly.
  5350. Subscribe (at the home page) to get notified of new releases.
  5351. --------------------------------------------------------------------------------
  5352.  
  5353. You can now start typing FireHOL configuration directives.
  5354. Special interactive commands: help, show, quit
  5355.  
  5356. EOF
  5357.     
  5358.     while [ 1 = 1 ]
  5359.     do
  5360.         read -p "# FireHOL [${work_cmd}:${work_name}] > " -e -r
  5361.         test -z "${REPLY}" && continue
  5362.         
  5363.         set_work_function -ne "Executing user input"
  5364.         
  5365.         while [ 1 = 1 ]
  5366.         do
  5367.         
  5368.         set -- ${REPLY}
  5369.         
  5370.         case "${1}" in
  5371.             help)
  5372.                 ${CAT_CMD} <<EOF
  5373. You can use anything a FireHOL configuration file accepts, including variables,
  5374. loops, etc. Take only care to write loops in one row.
  5375.  
  5376. Additionaly, you can use the following commands:
  5377.     
  5378.     help    to print this text on your screen.
  5379.     
  5380.     show    to show all the successfull commands so far.
  5381.     
  5382.     quit    to show the interactively given configuration file
  5383.         and quit.
  5384.     
  5385.     in    same as typing: interface eth0 internet
  5386.         This is used as a shortcut to get into the server/client
  5387.         mode in which you can test the rules for certain
  5388.         services.
  5389.  
  5390. EOF
  5391.                 break
  5392.                 ;;
  5393.                 
  5394.             show)
  5395.                 echo
  5396.                 ${CAT_CMD} "${FIREHOL_TEMP_CONFIG}"
  5397.                 echo
  5398.                 break
  5399.                 ;;
  5400.                 
  5401.             quit)
  5402.                 echo
  5403.                 ${CAT_CMD} "${FIREHOL_TEMP_CONFIG}"
  5404.                 echo
  5405.                 exit 1
  5406.                 ;;
  5407.                 
  5408.             in)
  5409.                 REPLY="interface eth0 internet"
  5410.                 continue
  5411.                 ;;
  5412.                 
  5413.             *)
  5414.                 ${CAT_CMD} <<EOF
  5415.  
  5416. # \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
  5417. # Cmd Line : ${FIREHOL_LINEID}
  5418. # Command  : ${REPLY}
  5419. EOF
  5420.                 eval "$@"
  5421.                 if [ $? -gt 0 ]
  5422.                 then
  5423.                     printf "\n# > FAILED <\n"
  5424.                 else
  5425.                     if [ "${1}" = "interface" -o "${1}" = "router" ]
  5426.                     then
  5427.                         echo >>"${FIREHOL_TEMP_CONFIG}"
  5428.                     else
  5429.                         printf "    " >>"${FIREHOL_TEMP_CONFIG}"
  5430.                     fi
  5431.                     
  5432.                     printf "%s\n" "${REPLY}" >>"${FIREHOL_TEMP_CONFIG}"
  5433.                     
  5434.                     FIREHOL_LINEID=$[FIREHOL_LINEID + 1]
  5435.                     
  5436.                     printf "\n# > OK <\n"
  5437.                 fi
  5438.                 break
  5439.                 ;;
  5440.         esac
  5441.         
  5442.         break
  5443.         done
  5444.     done
  5445.     
  5446.     exit 0
  5447. fi
  5448.  
  5449.  
  5450. # ------------------------------------------------------------------------------
  5451. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  5452. # ------------------------------------------------------------------------------
  5453. #
  5454. # MAIN PROCESSING - help wizard
  5455. #
  5456. # ------------------------------------------------------------------------------
  5457. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  5458. # ------------------------------------------------------------------------------
  5459.  
  5460. if [ ${FIREHOL_WIZARD} -eq 1 ]
  5461. then
  5462.     wizard_ask() {
  5463.         local prompt="${1}"; shift
  5464.         local def="${1}"; shift
  5465.         
  5466.         echo
  5467.         
  5468.         while [ 1 = 1 ]
  5469.         do
  5470.             printf >&2 "%s [%s] > " "${prompt}" "${def}"
  5471.             read
  5472.             
  5473.             local ans="${REPLY}"
  5474.             
  5475.             test -z "${ans}" && ans="${def}"
  5476.             
  5477.             local c=0
  5478.             while [ $c -le $# ]
  5479.             do
  5480.                 eval local t="\${${c}}"
  5481.                 
  5482.                 test "${ans}" = "${t}" && break
  5483.                 c=$[c + 1]
  5484.             done
  5485.             
  5486.             test $c -le $# && return $c
  5487.             
  5488.             printf >&2 "*** '${ans}' is not a valid answer. Pick one of "
  5489.             printf >&2 "%s " "$@"
  5490.             echo >&2 
  5491.             echo >&2 
  5492.         done
  5493.         
  5494.         return 0
  5495.     }
  5496.     
  5497.     ip_in_net() {
  5498.         local ip="${1}"; shift
  5499.         local net="${1}"; shift
  5500.         
  5501.         if [ -z "${ip}" -o -z "${net}" ]
  5502.         then
  5503.             return 1
  5504.         fi
  5505.         
  5506.         test "${net}" = "default" && net="0.0.0.0/0"
  5507.         
  5508.         set -- `echo ${ip} | ${TR_CMD} './' '  '`
  5509.         local i1=${1}
  5510.         local i2=${2}
  5511.         local i3=${3}
  5512.         local i4=${4}
  5513.         
  5514.         set -- `echo ${net} | ${TR_CMD} './' '  '`
  5515.         local n1=${1}
  5516.         local n2=${2}
  5517.         local n3=${3}
  5518.         local n4=${4}
  5519.         local n5=${5:-32}
  5520.         
  5521.         local i=$[i1*256*256*256 + i2*256*256 + i3*256 + i4]
  5522.         local n=$[n1*256*256*256 + n2*256*256 + n3*256 + n4]
  5523.         
  5524. #        echo "IP : '${i1}' . '${i2}' . '${i3}' . '${i4}'"
  5525. #        echo "NET: '${n1}' . '${n2}' . '${n3}' . '${n4}' / '${n5}'"
  5526.         
  5527.         local d=1
  5528.         local c=${n5}
  5529.         while [ $c -lt 32 ]
  5530.         do
  5531.             c=$[c + 1]
  5532.             d=$[d * 2]
  5533.         done
  5534.         
  5535.         local nm=$[n + d - 1]
  5536.         
  5537.         printf "### DEBUG: Is ${ip} part of network ${net}? "
  5538.         
  5539.         if [ ${i} -ge ${n} -a ${i} -le ${nm} ]
  5540.         then
  5541.             echo "yes"
  5542.             return 0
  5543.         else
  5544.             echo "no"
  5545.             return 1
  5546.         fi
  5547.     }
  5548.     
  5549.     ip_is_net() {
  5550.         local ip="${1}"; shift
  5551.         local net="${1}"; shift
  5552.         
  5553.         if [ -z "${ip}" -o -z "${net}" ]
  5554.         then
  5555.             return 1
  5556.         fi
  5557.         
  5558.         test "${net}" = "default" && net="0.0.0.0/0"
  5559.         
  5560.         set -- `echo ${ip} | ${TR_CMD} './' '  '`
  5561.         local i1=${1}
  5562.         local i2=${2}
  5563.         local i3=${3}
  5564.         local i4=${4}
  5565.         local i5=${5:-32}
  5566.         
  5567.         set -- `echo ${net} | ${TR_CMD} './' '  '`
  5568.         local n1=${1}
  5569.         local n2=${2}
  5570.         local n3=${3}
  5571.         local n4=${4}
  5572.         local n5=${5:-32}
  5573.         
  5574.         local i=$[i1*256*256*256 + i2*256*256 + i3*256 + i4]
  5575.         local n=$[n1*256*256*256 + n2*256*256 + n3*256 + n4]
  5576.         
  5577.         if [ ${i} -eq ${n} -a ${i5} -eq ${n5} ]
  5578.         then
  5579.             return 0
  5580.         else
  5581.             return 1
  5582.         fi
  5583.     }
  5584.     
  5585.     ip2net() {
  5586.         local ip="${1}"; shift
  5587.         
  5588.         if [ -z "${ip}" ]
  5589.         then
  5590.             return 0
  5591.         fi
  5592.         
  5593.         if [ "${ip}" = "default" ]
  5594.         then
  5595.             echo "default"
  5596.             return 0
  5597.         fi
  5598.         
  5599.         set -- `echo ${ip} | ${TR_CMD} './' '  '`
  5600.         local i1=${1}
  5601.         local i2=${2}
  5602.         local i3=${3}
  5603.         local i4=${4}
  5604.         local i5=${5:-32}
  5605.         
  5606.         echo ${i1}.${i2}.${i3}.${i4}/${i5}
  5607.     }
  5608.     
  5609.     ips2net() {
  5610.         
  5611.         (
  5612.             if [ "A${1}" = "A-" ]
  5613.             then
  5614.                 while read ip
  5615.                 do
  5616.                     ip2net ${ip}
  5617.                 done
  5618.             else
  5619.                 while [ ! -z "${1}" ]
  5620.                 do
  5621.                     ip2net ${1}
  5622.                     shift 
  5623.                 done
  5624.             fi
  5625.         ) | ${SORT_CMD} | ${UNIQ_CMD} | ${TR_CMD} "\n" " "
  5626.     }
  5627.     
  5628.     cd "${FIREHOL_DIR}"
  5629.     "${MKDIR_CMD}" ports
  5630.     "${MKDIR_CMD}" keys
  5631.     cd ports
  5632.     "${MKDIR_CMD}" tcp
  5633.     "${MKDIR_CMD}" udp
  5634.     
  5635.     "${CAT_CMD}" >&2 <<EOF
  5636.  
  5637. $Id: firehol.sh,v 1.226 2005/01/25 21:28:19 ktsaou Exp $
  5638. (C) Copyright 2003, Costa Tsaousis <costa@tsaousis.gr>
  5639. FireHOL is distributed under GPL.
  5640. Home Page: http://firehol.sourceforge.net
  5641.  
  5642. --------------------------------------------------------------------------------
  5643. FireHOL controls your firewall. You should want to get updates quickly.
  5644. Subscribe (at the home page) to get notified of new releases.
  5645. --------------------------------------------------------------------------------
  5646.  
  5647. FireHOL will now try to figure out its configuration file on this system.
  5648. Please have all the services and network interfaces on this system running.
  5649.  
  5650. Your running firewall will not be stopped or altered.
  5651.  
  5652. You can re-run the same command with output redirection to get the config
  5653. to a file. Example:
  5654.  
  5655. EOF
  5656.     echo >&2 "${FIREHOL_FILE} helpme >/tmp/firehol.conf"
  5657.     echo >&2 
  5658.     echo >&2 
  5659.         
  5660.     echo >&2 
  5661.     echo >&2 "Building list of known services."
  5662.     echo >&2 "Please wait..."
  5663.     
  5664.     ${CAT_CMD} /etc/services    |\
  5665.         ${TR_CMD} '\t' ' '    |\
  5666.         ${SED_CMD} "s/ \+/ /g"    >services
  5667.     
  5668.     for c in `echo ${!server_*} | ${TR_CMD} ' ' '\n' | ${GREP_CMD} "_ports$"`
  5669.     do
  5670.         serv=`echo $c | ${SED_CMD} "s/server_//" | ${SED_CMD} "s/_ports//"`
  5671.         
  5672.         eval "ret=\${$c}"
  5673.         for x in ${ret}
  5674.         do
  5675.             proto=`echo $x | ${CUT_CMD} -d '/' -f 1`
  5676.             port=`echo $x | ${CUT_CMD} -d '/' -f 2`
  5677.             
  5678.             test ! -d "${proto}" && continue
  5679.             
  5680.             nport=`${EGREP_CMD} "^${port}[[:space:]][0-9]+/${proto}" services | ${CUT_CMD} -d ' ' -f 2 | ${CUT_CMD} -d '/' -f 1`
  5681.             test -z "${nport}" && nport="${port}"
  5682.             
  5683.             echo "server ${serv}" >"${proto}/${nport}"
  5684.         done
  5685.     done
  5686.     
  5687.     echo "server ftp" >tcp/21
  5688.     echo "server nfs" >udp/2049
  5689.     
  5690.     echo "client amanda" >udp/10080
  5691.     
  5692.     echo "server dhcp" >udp/67
  5693.     echo "server dhcp" >tcp/67
  5694.     
  5695.     echo "client dhcp" >udp/68
  5696.     echo "client dhcp" >tcp/68
  5697.     
  5698.     echo "server emule" >tcp/4662
  5699.     
  5700.     echo "server pptp" >tcp/1723
  5701.     
  5702.     echo "server samba" >udp/137
  5703.     echo "server samba" >udp/138
  5704.     echo "server samba" >tcp/139
  5705.     
  5706.     
  5707.     wizard_ask "Press RETURN to start." "continue" "continue"
  5708.     
  5709.     echo >&2 
  5710.     echo >&2 "--- snip --- snip --- snip --- snip ---"
  5711.     echo >&2 
  5712.     
  5713.     echo "#!${FIREHOL_FILE}"
  5714.     echo "# ------------------------------------------------------------------------------"
  5715.     echo "# This feature is under construction -- use it with care."
  5716.     echo "#             *** NEVER USE THIS CONFIG AS-IS ***"
  5717.     echo "# "
  5718.  
  5719.     ${CAT_CMD} <<EOF
  5720. # $Id: firehol.sh,v 1.226 2005/01/25 21:28:19 ktsaou Exp $
  5721. # (C) Copyright 2003, Costa Tsaousis <costa@tsaousis.gr>
  5722. # FireHOL is distributed under GPL.
  5723. # Home Page: http://firehol.sourceforge.net
  5724. # 
  5725. # ------------------------------------------------------------------------------
  5726. # FireHOL controls your firewall. You should want to get updates quickly.
  5727. # Subscribe (at the home page) to get notified of new releases.
  5728. # ------------------------------------------------------------------------------
  5729. #
  5730. EOF
  5731.     echo "# This config will have the same effect as NO PROTECTION!"
  5732.     echo "# Everything that found to be running, is allowed."
  5733.     echo "# "
  5734.     echo "# Date: `${DATE_CMD}` on host `${HOSTNAME_CMD}`"
  5735.     echo "# "
  5736.     echo "# The TODOs bellow, are YOUR to-dos!"
  5737.     echo
  5738.     
  5739.     # globals for routing
  5740.     set -a found_interfaces=
  5741.     set -a found_ips=
  5742.     set -a found_nets=
  5743.     set -a found_excludes=
  5744.     
  5745.     helpme_iface() {
  5746.         local route="${1}"; shift
  5747.         local i="${1}"; shift
  5748.         local iface="${1}"; shift
  5749.         local ifip="${1}"; shift
  5750.         local ifnets="${1}"; shift
  5751.         local ifreason="${1}"; shift
  5752.         
  5753.         # one argument left: ifnets_excluded
  5754.         
  5755.         if [ "${route}" = "route" ]
  5756.         then
  5757.             found_interfaces[$i]="${iface}"
  5758.             found_ips[$i]="${ifip}"
  5759.             found_nets[$i]="${ifnets}"
  5760.             found_excludes[$i]="${1}"
  5761.         fi
  5762.         
  5763.         if [ "${ifnets}" = "default" ]
  5764.         then
  5765.             ifnets="not \"\${UNROUTABLE_IPS} ${1}\""
  5766.         else
  5767.             ifnets="\"${ifnets}\""
  5768.         fi
  5769.         
  5770.         # output the interface
  5771.         echo
  5772.         echo "# Interface No $i."
  5773.         echo "# The purpose of this interface is to control the traffic"
  5774.         if [ ! -z "${ifreason}" ]
  5775.         then
  5776.             echo "# ${ifreason}."
  5777.         else
  5778.             echo "# on the ${iface} interface with IP ${ifip} (net: ${ifnets})."
  5779.         fi
  5780.         echo "# TODO: Change \"interface${i}\" to something with meaning to you."
  5781.         echo "# TODO: Check the optional rule parameters (src/dst)."
  5782.         echo "# TODO: Remove 'dst ${ifip}' if this is dynamically assigned."
  5783.         echo "interface ${iface} interface${i} src ${ifnets} dst ${ifip}"
  5784.         echo
  5785.         echo "    # The default policy is DROP. You can be more polite with REJECT."
  5786.         echo "    # Prefer to be polite on your own clients to prevent timeouts."
  5787.         echo "    policy drop"
  5788.         echo
  5789.         echo "    # If you don't trust the clients behind ${iface} (net ${ifnets}),"
  5790.         echo "    # add something like this."
  5791.         echo "    # > protection strong"
  5792.         echo
  5793.         echo "    # Here are the services listening on ${iface}."
  5794.         echo "    # TODO: Normally, you will have to remove those not needed."
  5795.         
  5796.         (
  5797.             local x=
  5798.             local ports=
  5799.             for x in `${NETSTAT_CMD} -an | ${EGREP_CMD} "^tcp" | ${GREP_CMD} "0.0.0.0:*" | ${EGREP_CMD} " (${ifip}|0.0.0.0):[0-9]+" | ${CUT_CMD} -d ':' -f 2 | ${CUT_CMD} -d ' ' -f 1 | ${SORT_CMD} -n | ${UNIQ_CMD}`
  5800.             do
  5801.                 if [ -f "tcp/${x}" ]
  5802.                 then
  5803.                     echo "    `${CAT_CMD} tcp/${x}` accept"
  5804.                 else
  5805.                     ports="${ports} tcp/${x}"
  5806.                 fi
  5807.             done
  5808.             
  5809.             for x in `${NETSTAT_CMD} -an | ${EGREP_CMD} "^udp" | ${GREP_CMD} "0.0.0.0:*" | ${EGREP_CMD} " (${ifip}|0.0.0.0):[0-9]+" | ${CUT_CMD} -d ':' -f 2 | ${CUT_CMD} -d ' ' -f 1 | ${SORT_CMD} -n | ${UNIQ_CMD}`
  5810.             do
  5811.                 if [ -f "udp/${x}" ]
  5812.                 then
  5813.                     echo "    `${CAT_CMD} udp/${x}` accept"
  5814.                 else
  5815.                     ports="${ports} udp/${x}"
  5816.                 fi
  5817.             done
  5818.             
  5819.             echo "    server ICMP accept"
  5820.             
  5821.             echo "${ports}" | ${TR_CMD} " " "\n" | ${SORT_CMD} -n | ${UNIQ_CMD} | ${TR_CMD} "\n" " " >unknown.ports
  5822.         ) | ${SORT_CMD} | ${UNIQ_CMD}
  5823.         
  5824.         echo
  5825.         echo "    # The following ${iface} server ports are not known by FireHOL:"
  5826.         echo "    # `${CAT_CMD} unknown.ports`"
  5827.         echo "    # TODO: If you need any of them, you should define new services."
  5828.         echo "    #       (see Adding Services at the web site - http://firehol.sf.net)."
  5829.         echo
  5830.         
  5831.         echo "    # The following means that this machine can REQUEST anything via ${iface}."
  5832.         echo "    # TODO: On production servers, avoid this and allow only the"
  5833.         echo "    #       client services you really need."
  5834.         echo "    client all accept"
  5835.         echo
  5836.     }
  5837.     
  5838.     interfaces=`${IP_CMD} link show | ${EGREP_CMD} "^[0-9A-Za-z]+:" | ${CUT_CMD} -d ':' -f 2 | ${SED_CMD} "s/^ //" | ${GREP_CMD} -v "^lo$" | ${SORT_CMD} | ${UNIQ_CMD} | ${TR_CMD} "\n" " "`
  5839.     gw_if=`${IP_CMD} route show | ${GREP_CMD} "^default" | ${SED_CMD} "s/dev /dev:/g" | ${TR_CMD} " " "\n" | ${GREP_CMD} "^dev:" | ${CUT_CMD} -d ':' -f 2`
  5840.     gw_ip=`${IP_CMD} route show | ${GREP_CMD} "^default" | ${SED_CMD} "s/via /via:/g" | ${TR_CMD} " " "\n" | ${GREP_CMD} "^via:" | ${CUT_CMD} -d ':' -f 2 | ips2net -`
  5841.     
  5842.     i=0
  5843.     for iface in ${interfaces}
  5844.     do
  5845.         echo "### DEBUG: Processing interface '${iface}'"
  5846.         ips=`${IP_CMD} addr show dev ${iface} | ${SED_CMD} "s/  / /g" | ${SED_CMD} "s/  / /g" | ${SED_CMD} "s/  / /g" | ${GREP_CMD} "^ inet " | ${CUT_CMD} -d ' ' -f 3 | ${CUT_CMD} -d '/' -f 1 | ips2net -`
  5847.         peer=`${IP_CMD} addr show dev ${iface} | ${SED_CMD} "s/  / /g" | ${SED_CMD} "s/  / /g" | ${SED_CMD} "s/  / /g" | ${SED_CMD} "s/peer /peer:/g" | ${TR_CMD} " " "\n" | ${GREP_CMD} "^peer:" | ${CUT_CMD} -d ':' -f 2 | ips2net -`
  5848.         nets=`${IP_CMD} route show dev ${iface} | ${CUT_CMD} -d ' ' -f 1 | ips2net -`
  5849.         
  5850.         if [ -z "${ips}" -o -z "${nets}" ]
  5851.         then
  5852.             echo
  5853.             echo "# Ignoring interface '${iface}' because does not have an IP or route."
  5854.             echo
  5855.             continue
  5856.         fi
  5857.         
  5858.         for ip in ${ips}
  5859.         do
  5860.             echo "### DEBUG: Processing IP ${ip} of interface '${iface}'"
  5861.             
  5862.             ifreason=""
  5863.             
  5864.             # find all the networks this IP can access directly
  5865.             # or through its peer
  5866.             netcount=0
  5867.             ifnets=
  5868.             ofnets=
  5869.             for net in ${nets}
  5870.             do
  5871.                 test "${net}" = "default" && continue
  5872.                 
  5873.                 found=1
  5874.                 ip_in_net ${ip} ${net}
  5875.                 found=$?
  5876.                 
  5877.                 if [ ${found} -gt 0 -a ! -z "${peer}" ]
  5878.                 then
  5879.                     ip_in_net ${peer} ${net}
  5880.                     found=$?
  5881.                 fi
  5882.                 
  5883.                 if [ ${found} -eq 0 ]
  5884.                 then
  5885.                     # Add it to ifnets
  5886.                     f=0; ff=0
  5887.                     while [ $f -lt $netcount ]
  5888.                     do
  5889.                         if ip_in_net ${net} ${ifnets[$f]}
  5890.                         then
  5891.                             # Already satisfied
  5892.                             ff=1
  5893.                         elif ip_in_net ${ifnets[$f]} ${net}
  5894.                         then
  5895.                             # New one is superset of old
  5896.                             ff=1
  5897.                             ifnets[$f]=${net}
  5898.                         fi
  5899.                         
  5900.                         f=$[f + 1]
  5901.                     done
  5902.                     
  5903.                     if [ $ff -eq 0 ]
  5904.                     then
  5905.                         # Add it
  5906.                         netcount=$[netcount + 1]
  5907.                         ifnets=(${net} ${ifnets[@]})
  5908.                     fi
  5909.                 else
  5910.                     ofnets=(${net} ${ofnets[@]})
  5911.                 fi
  5912.             done
  5913.             
  5914.             # find all the networks this IP can access through gateways
  5915.             if [ ! -z "${ofnets[*]}" ]
  5916.             then
  5917.                 for net in ${ofnets[@]}
  5918.                 do
  5919.                     test "${net}" = "default" && continue
  5920.                     
  5921.                     nn=`echo "${net}" | ${CUT_CMD} -d "/" -f 1`
  5922.                     gw=`${IP_CMD} route show ${nn} dev ${iface} | ${EGREP_CMD} "^${nn}[[:space:]]+via[[:space:]][0-9\.]+" | ${CUT_CMD} -d ' ' -f 3 | ips2net -`
  5923.                     test -z "${gw}" && continue
  5924.                     
  5925.                     for nn in ${ifnets[@]}
  5926.                     do
  5927.                         test "${nn}" = "default" && continue
  5928.                         
  5929.                         if ip_in_net ${gw} ${nn}
  5930.                         then
  5931.                             echo "### DEBUG: Route ${net} is accessed through ${gw}"
  5932.                             
  5933.                             # Add it to ifnets
  5934.                             f=0; ff=0
  5935.                             while [ $f -lt $netcount ]
  5936.                             do
  5937.                                 if ip_in_net ${net} ${ifnets[$f]}
  5938.                                 then
  5939.                                     # Already satisfied
  5940.                                     ff=1
  5941.                                 elif ip_in_net ${ifnets[$f]} ${net}
  5942.                                 then
  5943.                                     # New one is superset of old
  5944.                                     ff=1
  5945.                                     ifnets[$f]=${net}
  5946.                                 fi
  5947.                                 
  5948.                                 f=$[f + 1]
  5949.                             done
  5950.                             
  5951.                             if [ $ff -eq 0 ]
  5952.                             then
  5953.                                 # Add it
  5954.                                 netcount=$[netcount + 1]
  5955.                                 ifnets=(${net} ${ifnets[@]})
  5956.                             fi
  5957.                             break
  5958.                         fi
  5959.                     done
  5960.                 done
  5961.             fi
  5962.             
  5963.             # Don't produce an interface if this is just a peer that is also the default gw
  5964.             def_ignore_ifnets=0
  5965.             if (test ${netcount} -eq 1 -a "${gw_if}" = "${iface}" && ip_is_net "${peer}" "${ifnets[*]}" && ip_is_net "${gw_ip}" "${peer}")
  5966.             then
  5967.                 echo "### DEBUG: Skipping ${iface} peer ${ifnets[*]} only interface (default gateway)."
  5968.                 echo
  5969.                 def_ignore_ifnets=1
  5970.             else
  5971.                 i=$[i + 1]
  5972.                 helpme_iface route $i "${iface}" "${ip}" "${ifnets[*]}" "${ifreason}"
  5973.             fi
  5974.             
  5975.             # Is this interface the default gateway too?
  5976.             if [ "${gw_if}" = "${iface}" ]
  5977.             then
  5978.                 for nn in ${ifnets[@]}
  5979.                 do
  5980.                     if ip_in_net "${gw_ip}" ${nn}
  5981.                     then
  5982.                         echo "### DEBUG: Default gateway ${gw_ip} is part of network ${nn}"
  5983.                         
  5984.                         i=$[i + 1]
  5985.                         helpme_iface route $i "${iface}" "${ip}" "default" "from/to unknown networks behind the default gateway ${gw_ip}" "`test ${def_ignore_ifnets} -eq 0 && echo "${ifnets[*]}"`"
  5986.                         
  5987.                         break
  5988.                     fi
  5989.                 done
  5990.             fi
  5991.         done
  5992.     done
  5993.         
  5994.     echo
  5995.     echo "# The above $i interfaces were found active at this moment."
  5996.     echo "# Add more interfaces that can potentially be activated in the future."
  5997.     echo "# FireHOL will not complain if you setup a firewall on an interface that is"
  5998.     echo "# not active when you activate the firewall."
  5999.     echo "# If you don't setup an interface, FireHOL will drop all traffic from or to"
  6000.     echo "# this interface, if and when it becomes available."
  6001.     echo "# Also, if an interface name dynamically changes (i.e. ppp0 may become ppp1)"
  6002.     echo "# you can use the plus (+) character to match all of them (i.e. ppp+)."
  6003.     echo
  6004.     
  6005.     if [ "1" = "`${CAT_CMD} /proc/sys/net/ipv4/ip_forward`" ]
  6006.     then
  6007.         x=0
  6008.         i=0
  6009.         while [ $i -lt ${#found_interfaces[*]} ]
  6010.         do
  6011.             i=$[i + 1]
  6012.             
  6013.             inface="${found_interfaces[$i]}"
  6014.             src="${found_nets[$i]}"
  6015.             
  6016.             case "${src}" in
  6017.                 "default")
  6018.                     src="not \"\${UNROUTABLE_IPS} ${found_excludes[$i]}\""
  6019.                     ;;
  6020.                     
  6021.                     *)
  6022.                     src="\"${src}\""
  6023.                     ;;
  6024.             esac
  6025.             
  6026.             j=0
  6027.             while [ $j -lt ${#found_interfaces[*]} ]
  6028.             do
  6029.                 j=$[j + 1]
  6030.                 
  6031.                 test $j -eq $i && continue
  6032.                 
  6033.                 outface="${found_interfaces[$j]}"
  6034.                 dst="${found_nets[$j]}"
  6035.                 dst_ip="${found_ips[$j]}"
  6036.                 
  6037.                 case "${dst}" in
  6038.                     "default")
  6039.                         dst="not \"\${UNROUTABLE_IPS} ${found_excludes[$j]}\""
  6040.                         ;;
  6041.                         
  6042.                         *)
  6043.                         dst="\"${dst}\""
  6044.                         ;;
  6045.                 esac
  6046.                 
  6047.                 # Make sure we are not routing to the same subnet
  6048.                 test "${inface}" = "${outface}" -a "${src}" = "${dst}" && continue
  6049.                 
  6050.                 # Make sure this is not a duplicate router
  6051.                 key="`echo ${inface}/${src}-${outface}/${dst} | ${TR_CMD} "/ \\\$\\\"{}" "______"`"
  6052.                 test -f "${FIREHOL_DIR}/keys/${key}" && continue
  6053.                 ${TOUCH_CMD} "${FIREHOL_DIR}/keys/${key}"
  6054.                 
  6055.                 x=$[x + 1]
  6056.                 
  6057.                 echo
  6058.                 echo "# Router No ${x}."
  6059.                 echo "# Clients on ${inface} (from ${src}) accessing servers on ${outface} (to ${dst})."
  6060.                 echo "# TODO: Change \"router${x}\" to something with meaning to you."
  6061.                 echo "# TODO: Check the optional rule parameters (src/dst)."
  6062.                 echo "router router${x} inface ${inface} outface ${outface} src ${src} dst ${dst}"
  6063.                 echo 
  6064.                 echo "    # If you don't trust the clients on ${inface} (from ${src}), or"
  6065.                 echo "    # if you want to protect the servers on ${outface} (to ${dst}),"
  6066.                 echo "    # uncomment the following line."
  6067.                 echo "    # > protection strong"
  6068.                 echo
  6069.                 echo "    # To NAT client requests on the output of ${outface}, add this."
  6070.                 echo "    # > masquerade"
  6071.                 
  6072.                 echo "    # Alternatively, you can SNAT them by placing this at the top of this config:"
  6073.                 echo "    # > snat to ${dst_ip} outface ${outface} src ${src} dst ${dst}"
  6074.                 echo "    # SNAT commands can be enhanced using 'proto', 'sport', 'dport', etc in order to"
  6075.                 echo "    # NAT only some specific traffic."
  6076.                 echo
  6077.                 echo "    # TODO: This will allow all traffic to pass."
  6078.                 echo "    # If you remove it, no REQUEST will pass matching this traffic."
  6079.                 echo "    route all accept"
  6080.                 echo
  6081.             done
  6082.         done
  6083.         
  6084.         if [ ${x} -eq 0 ]
  6085.         then
  6086.             echo
  6087.             echo
  6088.             echo "# No router statements have been produced, because your server"
  6089.             echo "# does not seem to need any."
  6090.             echo
  6091.         fi
  6092.     else
  6093.         echo
  6094.         echo
  6095.         echo "# No router statements have been produced, because your server"
  6096.         echo "# is not configured for forwarding traffic."
  6097.         echo
  6098.     fi
  6099.     
  6100.     exit 0
  6101. fi
  6102.  
  6103. # ------------------------------------------------------------------------------
  6104. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  6105. # ------------------------------------------------------------------------------
  6106. #
  6107. # MAIN PROCESSING
  6108. #
  6109. # ------------------------------------------------------------------------------
  6110. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  6111. # ------------------------------------------------------------------------------
  6112.  
  6113. # --- Initialization -----------------------------------------------------------
  6114.  
  6115. fixed_iptables_save() {
  6116.     local tmp="${FIREHOL_DIR}/iptables-save-$$"
  6117.     local err=
  6118.     
  6119.     load_kernel_module ip_tables
  6120.     ${IPTABLES_SAVE_CMD} -c >$tmp
  6121.     err=$?
  6122.     if [ ! $err -eq 0 ]
  6123.     then
  6124.         ${RM_CMD} -f $tmp >/dev/null 2>&1
  6125.         return $err
  6126.     fi
  6127.     
  6128.     ${CAT_CMD} ${tmp} |\
  6129.         ${SED_CMD} "s/--uid-owner !/! --uid-owner /g"    |\
  6130.         ${SED_CMD} "s/--gid-owner !/! --gid-owner /g"    |\
  6131.         ${SED_CMD} "s/--pid-owner !/! --pid-owner /g"    |\
  6132.         ${SED_CMD} "s/--sid-owner !/! --sid-owner /g"    |\
  6133.         ${SED_CMD} "s/--cmd-owner !/! --cmd-owner /g"
  6134.     
  6135.     err=$?
  6136.     
  6137.     ${RM_CMD} -f $tmp >/dev/null 2>&1
  6138.     return $err
  6139. }
  6140.  
  6141. echo -n $"FireHOL: Saving your old firewall to a temporary file:"
  6142. fixed_iptables_save >${FIREHOL_SAVED}
  6143. if [ $? -eq 0 ]
  6144. then
  6145.     success $"FireHOL: Saving your old firewall to a temporary file:"
  6146.     echo
  6147. else
  6148.     test -f "${FIREHOL_SAVED}" && ${RM_CMD} -f "${FIREHOL_SAVED}"
  6149.     failure $"FireHOL: Saving your old firewall to a temporary file:"
  6150.     echo
  6151.     exit 1
  6152. fi
  6153.  
  6154.  
  6155. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  6156.  
  6157. # Place all the statements bellow to the beginning of the final firewall script.
  6158. ${CAT_CMD} >"${FIREHOL_OUTPUT}" <<EOF
  6159. #!/bin/sh
  6160.  
  6161. load_kernel_module ip_tables
  6162. load_kernel_module ip_conntrack
  6163.  
  6164. # Find all tables supported
  6165. tables=\`${CAT_CMD} /proc/net/ip_tables_names\`
  6166. for t in \${tables}
  6167. do
  6168.     # Reset/empty this table.
  6169.     ${IPTABLES_CMD} -t "\${t}" -F >${FIREHOL_OUTPUT}.log 2>&1
  6170.     r=\$?; test ! \${r} -eq 0 && runtime_error error \${r} INIT ${IPTABLES_CMD} -t "\${t}" -F
  6171.     
  6172.     ${IPTABLES_CMD} -t "\${t}" -X >${FIREHOL_OUTPUT}.log 2>&1
  6173.     r=\$?; test ! \${r} -eq 0 && runtime_error error \${r} INIT ${IPTABLES_CMD} -t "\${t}" -X
  6174.     
  6175.     ${IPTABLES_CMD} -t "\${t}" -Z >${FIREHOL_OUTPUT}.log 2>&1
  6176.     r=\$?; test ! \${r} -eq 0 && runtime_error error \${r} INIT ${IPTABLES_CMD} -t "\${t}" -Z
  6177.     
  6178.     # Find all default chains in this table.
  6179.     chains=\`${IPTABLES_CMD} -t "\${t}" -nL | ${GREP_CMD} "^Chain " | ${CUT_CMD} -d ' ' -f 2\`
  6180.     
  6181.     # If this is the 'filter' table, remember the default chains.
  6182.     # This will be used at the end to make it DROP all packets.
  6183.     test "\${t}" = "filter" && firehol_filter_chains="\${chains}"
  6184.     
  6185.     # Set the policy to ACCEPT on all default chains.
  6186.     for c in \${chains}
  6187.     do
  6188.         ${IPTABLES_CMD} -t "\${t}" -P "\${c}" ACCEPT >${FIREHOL_OUTPUT}.log 2>&1
  6189.         r=\$?; test ! \${r} -eq 0 && runtime_error error \${r} INIT ${IPTABLES_CMD} -t "\${t}" -P "\${c}" ACCEPT
  6190.     done
  6191. done
  6192.  
  6193. ${IPTABLES_CMD} -t filter -P INPUT "\${FIREHOL_INPUT_ACTIVATION_POLICY}" >${FIREHOL_OUTPUT}.log 2>&1
  6194. r=\$?; test ! \${r} -eq 0 && runtime_error error \${r} INIT ${IPTABLES_CMD} -t filter -P INPUT "\${FIREHOL_INPUT_ACTIVATION_POLICY}"
  6195.  
  6196. ${IPTABLES_CMD} -t filter -P OUTPUT "\${FIREHOL_OUTPUT_ACTIVATION_POLICY}" >${FIREHOL_OUTPUT}.log 2>&1
  6197. r=\$?; test ! \${r} -eq 0 && runtime_error error \${r} INIT ${IPTABLES_CMD} -t filter -P OUTPUT "\${FIREHOL_OUTPUT_ACTIVATION_POLICY}"
  6198.  
  6199. ${IPTABLES_CMD} -t filter -P FORWARD "\${FIREHOL_FORWARD_ACTIVATION_POLICY}" >${FIREHOL_OUTPUT}.log 2>&1
  6200. r=\$?; test ! \${r} -eq 0 && runtime_error error \${r} INIT ${IPTABLES_CMD} -t filter -P FORWARD "\${FIREHOL_FORWARD_ACTIVATION_POLICY}"
  6201.  
  6202. # Accept everything in/out the loopback device.
  6203. if [ "\${FIREHOL_TRUST_LOOPBACK}" = "1" ]
  6204. then
  6205.     ${IPTABLES_CMD} -A INPUT -i lo -j ACCEPT
  6206.     ${IPTABLES_CMD} -A OUTPUT -o lo -j ACCEPT
  6207. fi
  6208.  
  6209. # Drop all invalid packets.
  6210. # Netfilter HOWTO suggests to DROP all INVALID packets.
  6211. if [ "\${FIREHOL_DROP_INVALID}" = "1" ]
  6212. then
  6213.     ${IPTABLES_CMD} -A INPUT -m state --state INVALID -j DROP
  6214.     ${IPTABLES_CMD} -A OUTPUT -m state --state INVALID -j DROP
  6215.     ${IPTABLES_CMD} -A FORWARD -m state --state INVALID -j DROP
  6216. fi
  6217.  
  6218. EOF
  6219.  
  6220. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  6221.  
  6222. echo -n $"FireHOL: Processing file ${FIREHOL_CONFIG}:"
  6223. ret=0
  6224.  
  6225. # ------------------------------------------------------------------------------
  6226. # Create a small awk script that inserts line numbers in the configuration file
  6227. # just before each known directive.
  6228. # These line numbers will be used for debugging the configuration script.
  6229.  
  6230. ${CAT_CMD} >"${FIREHOL_TMP}.awk" <<"EOF"
  6231. /^[[:space:]]*blacklist[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6232. /^[[:space:]]*client[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6233. /^[[:space:]]*dnat[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6234. /^[[:space:]]*dscp[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6235. /^[[:space:]]*interface[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6236. /^[[:space:]]*iptables[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6237. /^[[:space:]]*mac[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6238. /^[[:space:]]*mark[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6239. /^[[:space:]]*masquerade[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6240. /^[[:space:]]*nat[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6241. /^[[:space:]]*policy[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6242. /^[[:space:]]*postprocess[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6243. /^[[:space:]]*protection[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6244. /^[[:space:]]*redirect[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6245. /^[[:space:]]*router[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6246. /^[[:space:]]*route[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6247. /^[[:space:]]*server[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6248. /^[[:space:]]*snat[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6249. /^[[:space:]]*tcpmss[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6250. /^[[:space:]]*tos[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6251. /^[[:space:]]*transparent_squid[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6252. /^[[:space:]]*transparent_proxy[[:space:]]/ { printf "FIREHOL_LINEID=${LINENO} " }
  6253. { print }
  6254. EOF
  6255.  
  6256. ${CAT_CMD} ${FIREHOL_CONFIG} | ${GAWK_CMD} -f "${FIREHOL_TMP}.awk" >${FIREHOL_TMP}
  6257. ${RM_CMD} -f "${FIREHOL_TMP}.awk"
  6258.  
  6259. # ------------------------------------------------------------------------------
  6260. # Run the configuration file.
  6261.  
  6262. enable -n trap            # Disable the trap buildin shell command.
  6263. enable -n exit            # Disable the exit buildin shell command.
  6264. source ${FIREHOL_TMP} "$@"    # Run the configuration as a normal script.
  6265. FIREHOL_LINEID="FIN"
  6266. enable trap            # Enable the trap buildin shell command.
  6267. enable exit            # Enable the exit buildin shell command.
  6268.  
  6269.  
  6270. close_cmd                    || ret=$[ret + 1]
  6271. close_master                    || ret=$[ret + 1]
  6272.  
  6273. ${CAT_CMD} >>"${FIREHOL_OUTPUT}" <<EOF
  6274.  
  6275. # Make it drop everything on table 'filter'.
  6276. for c in \${firehol_filter_chains}
  6277. do
  6278.     ${IPTABLES_CMD} -t filter -P "\${c}" DROP >${FIREHOL_OUTPUT}.log 2>&1
  6279.     r=\$?; test ! \${r} -eq 0 && runtime_error error \${r} INIT ${IPTABLES_CMD} -t filter -P "\${c}" DROP
  6280. done
  6281.  
  6282. EOF
  6283.  
  6284. if [ ${work_error} -gt 0 -o $ret -gt 0 ]
  6285. then
  6286.     echo >&2
  6287.     echo >&2 "NOTICE: No changes made to your firewall."
  6288.     failure $"FireHOL: Processing file ${FIREHOL_CONFIG}:"
  6289.     echo
  6290.     exit 1
  6291. fi
  6292.  
  6293. success $"FireHOL: Processing file ${FIREHOL_CONFIG}:"
  6294. echo
  6295.  
  6296.  
  6297. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  6298.  
  6299. for m in ${FIREHOL_KERNEL_MODULES}
  6300. do
  6301.     postprocess -ne load_kernel_module $m
  6302. done
  6303.  
  6304. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  6305.  
  6306. if [ $FIREHOL_ROUTING -eq 1 ]
  6307. then
  6308.     postprocess ${SYSCTL_CMD} -w "net.ipv4.ip_forward=1"
  6309. fi
  6310.  
  6311. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  6312.  
  6313. if [ ${FIREHOL_DEBUG} -eq 1 ]
  6314. then
  6315.     ${CAT_CMD} ${FIREHOL_OUTPUT}
  6316.     
  6317.     exit 1
  6318. fi
  6319.  
  6320.  
  6321. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  6322.  
  6323. echo -n $"FireHOL: Activating new firewall (${FIREHOL_COMMAND_COUNTER} rules):"
  6324.  
  6325. source ${FIREHOL_OUTPUT} "$@"
  6326.  
  6327. if [ ${work_final_status} -gt 0 ]
  6328. then
  6329.     failure $"FireHOL: Activating new firewall:"
  6330.     echo
  6331.     
  6332.     # The trap will restore the firewall.
  6333.     
  6334.     exit 1
  6335. fi
  6336. success $"FireHOL: Activating new firewall (${FIREHOL_COMMAND_COUNTER} rules):"
  6337. echo
  6338.  
  6339. if [ ${FIREHOL_TRY} -eq 1 ]
  6340. then
  6341.     read -p "Keep the firewall? (type 'commit' to accept - 30 seconds timeout) : " -t 30 -e
  6342.     ret=$?
  6343.     echo
  6344.     if [ ! $ret -eq 0 -o ! "${REPLY}" = "commit" ]
  6345.     then
  6346.         # The trap will restore the firewall.
  6347.         
  6348.         exit 1
  6349.     else
  6350.         echo "Successfull activation of FireHOL firewall."
  6351.     fi
  6352. fi
  6353.  
  6354. # Remove the saved firewall, so that the trap will not restore it.
  6355. ${RM_CMD} -f "${FIREHOL_SAVED}"
  6356.  
  6357. # RedHat startup service locking.
  6358. if [ -d /var/lock/subsys ]
  6359. then
  6360.     ${TOUCH_CMD} /var/lock/subsys/iptables
  6361.     ${TOUCH_CMD} /var/lock/subsys/firehol
  6362. fi
  6363.  
  6364.  
  6365. # XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  6366.  
  6367. if [ ${FIREHOL_SAVE} -eq 1 ]
  6368. then
  6369.     if [ -z "${FIREHOL_AUTOSAVE}" ]
  6370.     then
  6371.         if [ -d "/etc/sysconfig" ]
  6372.         then
  6373.             # RedHat
  6374.             FIREHOL_AUTOSAVE="/etc/sysconfig/iptables"
  6375.         elif [ -d "/var/lib/iptables" ]
  6376.         then
  6377.             if [ -f /etc/conf.d/iptables ]
  6378.             then
  6379.                 # Gentoo
  6380.                 IPTABLES_SAVE=
  6381.                 
  6382.                 . /etc/conf.d/iptables
  6383.                 FIREHOL_AUTOSAVE="${IPTABLES_SAVE}"
  6384.             fi
  6385.             
  6386.             if [ -z "${FIREHOL_AUTOSAVE}" ]
  6387.             then
  6388.                 # Debian
  6389.                 FIREHOL_AUTOSAVE="/var/lib/iptables/autosave"
  6390.             fi
  6391.         else
  6392.             error "Cannot find where to save iptables file. Please set FIREHOL_AUTOSAVE."
  6393.             echo
  6394.             exit 1
  6395.         fi
  6396.     fi
  6397.     
  6398.     echo -n $"FireHOL: Saving firewall to ${FIREHOL_AUTOSAVE}:"
  6399.     
  6400.     fixed_iptables_save >"${FIREHOL_AUTOSAVE}"
  6401.     
  6402.     if [ ! $? -eq 0 ]
  6403.     then
  6404.         failure $"FireHOL: Saving firewall to ${FIREHOL_AUTOSAVE}:"
  6405.         echo
  6406.         exit 1
  6407.     fi
  6408.     
  6409.     success $"FireHOL: Saving firewall to ${FIREHOL_AUTOSAVE}:"
  6410.     echo
  6411.     exit 0
  6412. fi
  6413.